package com.wicket.okrcomponent.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrcomponent.biz.service.dto.common.*;
import com.wicket.okrcomponent.biz.service.dto.req.*;
import com.wicket.okrcomponent.biz.service.dto.res.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import com.wicket.okrcomponent.common.util.CommonFunctionHelper;
import com.wicket.okrcomponent.common.util.RedisUtil;
import com.wicket.okrcomponent.common.exception.BizException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;

import java.util.List;
import java.util.stream.Collectors;
import com.wicket.okrcomponent.biz.service.nb.NbInterfaceMode;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrcomponent.common.exception.Assert;
import com.wicket.okrcomponent.base.service.MCustomFields3Service;
import com.wicket.okrcomponent.dal.po.mbg.CustomFields3;
import com.wicket.okrcomponent.base.service.dto.req.ImplementAnalyzeNaturalDayDataReq;
import com.wicket.okrcomponent.base.service.MOmsSchemeOpenRecordService;
import java.util.Collections;
import com.wicket.okrcomponent.base.service.MOmsUnstructuredDataService;
import com.wicket.okrcomponent.base.service.MOmsConfApplexRelService;
import com.wicket.okrcomponent.biz.service.ConfSchemeService;
import com.wicket.okrcomponent.common.dto.TreeNode;
import java.util.ArrayList;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class InterfaceModeServiceImpl implements com.wicket.okrcomponent.biz.service.InterfaceModeService {
    @Resource
    private RedisUtil redisUtil;
//@Resource
 //private MCustomFieldsService mCustomFieldsService;
@Resource
  private NbInterfaceMode nbInterfaceMode;
@Resource
  private MOmsSchemeOpenRecordService mOmsSchemeOpenRecordService;
@Resource
  private MOmsUnstructuredDataService mOmsUnstructuredDataService;
@Resource
  private MOmsConfApplexRelService mOmsConfApplexRelService;
@Resource
  private ConfSchemeService confSchemeService;
//@Resource
 //private MOmsCycleService mOmsCycleService;
//@Resource
 //private MCustomFields4Service mCustomFields4Service;
//@Resource
 //private MCustomFields5Service mCustomFields5Service;
//@Resource
 //private MMmmShellService mMmmShellService;
//@Resource
 //private MSystemPersonInfoService mSystemPersonInfoService;
//@Resource
 //private MOmsBasicInstanceUnstructuredRelationshipService mOmsBasicInstanceUnstructuredRelationshipService;
//@Resource
 //private MCustomFields2Service mCustomFields2Service;
//@Resource
 //private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
//@Resource
 //private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
//@Resource
// private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
//@Resource
 //private MCustomFields3Service mCustomFields3Service;
/**
   * D2执行数据集相减得结果(公共)[4637]
   * gen by moon at 10/1/2022, 11:28:37 PM
   */
  @Trace(operationName = "D2执行数据集相减得结果(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSetSubtractResultsComRespDto implementDataSetSubtractResultsCom(ImplementDataSetSubtractResultsComReqDto reqDto){
    
      
      ImplementDataSetSubtractResultsRespDto multiCollectionRemoveExistingDataRes_1 =null;
//步骤0: M2执行数据集相减得结果（特殊方法） - implementDataSetSubtractResults
     //ModelCode: multiCollectionRemoveExistingData
        ImplementDataSetSubtractResultsRespDto multiCollectionRemoveExistingDataRes = null;
    ImplementDataSetSubtractResultsReqDto multiCollectionRemoveExistingDataReq=new ImplementDataSetSubtractResultsReqDto();
  if(reqDto!=null){
      //list-field-assign
    multiCollectionRemoveExistingDataReq.setAllSingleFieldDataSetList(reqDto.getAllSingleFieldDataSetList());//sourceId:337134_1
//list-field-assign
    multiCollectionRemoveExistingDataReq.setDataSetSingleFieldPartList(reqDto.getDataSetSingleFieldPartList());//sourceId:337135_1
    }
  
    /*M2执行数据集相减得结果（特殊方法）[4595]  入参多个数据集。用第一个数据集（全量），排除第二、第三。。。数据集中已经存在的数据，将剩余的数据输出 */
    
      multiCollectionRemoveExistingDataRes = nbInterfaceMode.implementDataSetSubtractResults(multiCollectionRemoveExistingDataReq);
      
      
      multiCollectionRemoveExistingDataRes_1 = multiCollectionRemoveExistingDataRes;
    
ImplementDataSetSubtractResultsComRespDto retData = new ImplementDataSetSubtractResultsComRespDto();
  if(multiCollectionRemoveExistingDataRes_1!=null){
      //list-field-assign
    retData.setDataSetSubtractResultsList(multiCollectionRemoveExistingDataRes_1.getDataSetSubtractResultsList());//sourceId:337138_1
    }
  

  
  
return retData;
  }
/**
   * D2-执行集合去除已存在的数据服务(公共)[5111]
   * gen by moon at 12/1/2022, 1:28:43 AM
   */
  @Trace(operationName = "D2-执行集合去除已存在的数据服务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCollectionRemoveExistingDataComRespDto implementCollectionRemoveExistingDataCom(ImplementCollectionRemoveExistingDataComReqDto reqDto){
    
      
      ImplementCollectionRemoveExistingDataComRespDto collectionRemoveExistingDataRes_1 =null;
//步骤0: M2-执行集合去除已存在的数据服务(公共) - implementCollectionRemoveExistingDataCom
     //ModelCode: collectionRemoveExistingData
        ImplementCollectionRemoveExistingDataComRespDto collectionRemoveExistingDataRes = null;
    ImplementCollectionRemoveExistingDataComReqDto collectionRemoveExistingDataReq=new ImplementCollectionRemoveExistingDataComReqDto();
  if(reqDto!=null){
      collectionRemoveExistingDataReq.setAllSingleFieldDataSetList(reqDto.getAllSingleFieldDataSetList());//list-field-assign//sourceId:419613_1
collectionRemoveExistingDataReq.setDataSetSingleFieldPartList(reqDto.getDataSetSingleFieldPartList());//list-field-assign//sourceId:419614_1
    }
  
    /*M2-执行集合去除已存在的数据服务(公共)[5110]  入参两个数据集，通过已存在标识字段匹配，去除第一个数据集中已存在的第二个数据集的数据 */
    
      collectionRemoveExistingDataRes = nbInterfaceMode.implementCollectionRemoveExistingDataCom(collectionRemoveExistingDataReq);
      
      
      collectionRemoveExistingDataRes_1 = collectionRemoveExistingDataRes;
    
ImplementCollectionRemoveExistingDataComRespDto retData = new ImplementCollectionRemoveExistingDataComRespDto();
  if(collectionRemoveExistingDataRes_1!=null){
      retData.setDataSetRemoveExistingResultsList(collectionRemoveExistingDataRes_1.getDataSetRemoveExistingResultsList());//list-field-assign//sourceId:419618_1
    }
  

  
  
return retData;
  }
/**
   * D2执行数据集记录去重(公共)[5138]
   * gen by moon at 12/2/2022, 10:21:34 PM
   */
  @Trace(operationName = "D2执行数据集记录去重(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSetDuplicateRemovalComRespDto implementDataSetDuplicateRemovalCom(ImplementDataSetDuplicateRemovalComReqDto reqDto){
    
      
      AssemblyDataSetDuplicateRemovalRespDto collectionRemoveDuplicateDataRes_1 =null;
//步骤0: M2执行数据集记录去重（特殊方法） - implementDataSetDuplicateRemoval
     //ModelCode: collectionRemoveDuplicateData
        AssemblyDataSetDuplicateRemovalRespDto collectionRemoveDuplicateDataRes = null;
    AssemblyDataSetDuplicateRemovalReqDto collectionRemoveDuplicateDataReq=new AssemblyDataSetDuplicateRemovalReqDto();
  if(reqDto!=null){
      collectionRemoveDuplicateDataReq.setDataSetDuplicateRemovalList(reqDto.getDataSetDuplicateRemovalList());//list-field-assign//sourceId:422728_1
    }
  
    /*M2执行数据集记录去重（特殊方法）[5137]  入参一个数据集，通过去重标识，去除数据集中重复的数据 */
    
      collectionRemoveDuplicateDataRes = nbInterfaceMode.assemblyDataSetDuplicateRemoval(collectionRemoveDuplicateDataReq);
      
      
      collectionRemoveDuplicateDataRes_1 = collectionRemoveDuplicateDataRes;
    
ImplementDataSetDuplicateRemovalComRespDto retData = new ImplementDataSetDuplicateRemovalComRespDto();
  if(collectionRemoveDuplicateDataRes_1!=null){
      retData.setDataSetDuplicateRemovalList(collectionRemoveDuplicateDataRes_1.getDataSetDuplicateRemovalList());//list-field-assign//sourceId:422737_1
    }
  

  
  
return retData;
  }

/**
   * D2-执行数据集去除非空值数据服务(公共)[5142]
   * gen by moon at 11/6/2022, 3:35:27 AM
   */
  @Trace(operationName = "D2-执行数据集去除非空值数据服务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSetRemoveUnNullDataComRespDto implementDataSetRemoveUnNullDataCom(ImplementDataSetRemoveUnNullDataComReqDto reqDto){


      ImplementDataSetRemoveUnNullDataRespDto filterDataDelNullRecordRes_1 =null;
//步骤0: M2-执行数据集去除非空值数据 - implementDataSetRemoveUnNullData
     //ModelCode: filterDataDelNullRecord
        ImplementDataSetRemoveUnNullDataRespDto filterDataDelNullRecordRes = null;
    ImplementDataSetRemoveUnNullDataReqDto filterDataDelNullRecordReq=new ImplementDataSetRemoveUnNullDataReqDto();
  if(reqDto!= null&&  reqDto.getDataSetRemoveNullDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetRemoveNullDataList())){
      filterDataDelNullRecordReq.setDataSetRemoveNullDataList(reqDto.getDataSetRemoveNullDataList().stream().map(item -> BeanUtil.toBean(item, DataSetRemoveNullDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:422822_1
    }

    /*M2-执行数据集去除非空值数据[5141]  入参数据集，数据集主键A+非主键B，将B字段不为空的数据记录过滤掉（为空的出参） */

      filterDataDelNullRecordRes = nbInterfaceMode.implementDataSetRemoveUnNullData(filterDataDelNullRecordReq);


      filterDataDelNullRecordRes_1 = filterDataDelNullRecordRes;

ImplementDataSetRemoveUnNullDataComRespDto retData = new ImplementDataSetRemoveUnNullDataComRespDto();
  if(filterDataDelNullRecordRes_1!=null){
      retData.setDataSetRemoveNullDataList(filterDataDelNullRecordRes_1.getDataSetRemoveNullDataList());//list-field-assign//sourceId:422825_1
    }


  
  
return retData;
  }
/**
   * D2执行数据集加一条记录(公共)[5161]
   * gen by moon at 11/6/2022, 11:18:21 PM
   */
  @Trace(operationName = "D2执行数据集加一条记录(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSetPlusOneComRespDto implementDataSetPlusOneCom(ImplementDataSetPlusOneComReqDto reqDto){
    
      
      DataSetPlusOneAssemblyRespDto dataSetPlusOneAssemblyRes_1 =null;
//步骤0: M执行数据集加一条记录(特殊方法) - implementDataSetPlusOne
     //ModelCode: dataSetPlusOneAssembly
        DataSetPlusOneAssemblyRespDto dataSetPlusOneAssemblyRes = null;
    DataSetPlusOneAssemblyReqDto dataSetPlusOneAssemblyReq=new DataSetPlusOneAssemblyReqDto();
  if(reqDto!=null){
      dataSetPlusOneAssemblyReq.setDataSetPlusOneList(reqDto.getDataSetPlusOneList());//list-field-assign//sourceId:424341_1
dataSetPlusOneAssemblyReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:424342_1
    }
  
    /*M执行数据集加一条记录(特殊方法)[5160]  入参数据集和单记录，将单记录追加到数据集内 */
    Assert.isNull(dataSetPlusOneAssemblyReq.getCommPrimaryKey(),"D2执行数据集加一条记录(公共)-M执行数据集加一条记录(特殊方法)-通用主键ID不能为空",false);
      dataSetPlusOneAssemblyRes = nbInterfaceMode.dataSetPlusOneAssembly(dataSetPlusOneAssemblyReq);
      
      
      dataSetPlusOneAssemblyRes_1 = dataSetPlusOneAssemblyRes;
    
ImplementDataSetPlusOneComRespDto retData = new ImplementDataSetPlusOneComRespDto();
  if(dataSetPlusOneAssemblyRes_1!=null){
      retData.setDataSetPlusOneList(dataSetPlusOneAssemblyRes_1.getDataSetPlusOneList());//list-field-assign//sourceId:424346_1
    }
  

  
  
return retData;
  }
/**
   * D2执行数据集每条与单数值比较(公共)[5158]
   * gen by moon at 12/16/2022, 4:21:44 AM
   */
  @Trace(operationName = "D2执行数据集每条与单数值比较(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSetEachSingleValueComparisonComRespDto implementDataSetEachSingleValueComparisonCom(ImplementDataSetEachSingleValueComparisonComReqDto reqDto){
    
      
      ImplementDataSetEachSingleValueComparisonRespDto dataSetEachSingleValueComparisonRes_1 =null;
//步骤0: M21执行数据集每条与单数值比较(特殊方法) - implementDataSetEachSingleValueComparison
     //ModelCode: dataSetEachSingleValueComparison
        ImplementDataSetEachSingleValueComparisonRespDto dataSetEachSingleValueComparisonRes = null;
    ImplementDataSetEachSingleValueComparisonReqDto dataSetEachSingleValueComparisonReq=new ImplementDataSetEachSingleValueComparisonReqDto();
  if(reqDto!=null){
      dataSetEachSingleValueComparisonReq.setDataSetEachSingleValueComparisonList(reqDto.getDataSetEachSingleValueComparisonList());//list-field-assign//sourceId:424263_1
      dataSetEachSingleValueComparisonReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:519330_1
dataSetEachSingleValueComparisonReq.setCalcMaxAndMin(reqDto.getCalcMaxAndMin());//SimpleFieldAssign//sourceId:424403_1
    }
  
    /*M21执行数据集每条与单数值比较(特殊方法)[5157]  入参数据集与单数值，用数据集中每条记录的数值与数据集外的单数值进行比较 */
    Assert.isNull(dataSetEachSingleValueComparisonReq.getCalcPara2(),"D2执行数据集每条与单数值比较(公共)-M21执行数据集每条与单数值比较(特殊方法)-计算入参2不能为空",false);
Assert.isNull(dataSetEachSingleValueComparisonReq.getCalcMaxAndMin(),"D2执行数据集每条与单数值比较(公共)-M21执行数据集每条与单数值比较(特殊方法)-求最大最小值不能为空",false);
      dataSetEachSingleValueComparisonRes = nbInterfaceMode.implementDataSetEachSingleValueComparison(dataSetEachSingleValueComparisonReq);
      
      
      dataSetEachSingleValueComparisonRes_1 = dataSetEachSingleValueComparisonRes;
    
ImplementDataSetEachSingleValueComparisonComRespDto retData = new ImplementDataSetEachSingleValueComparisonComRespDto();
  if(dataSetEachSingleValueComparisonRes_1!=null){
      retData.setLogicalOperator(dataSetEachSingleValueComparisonRes_1.getLogicalOperator());//SimpleFieldAssign//sourceId:424268_1
    }
  

  
  
return retData;
  }
/**
   * D2执行数据集数值相加与单数值比较(公共)[5156]
   * gen by moon at 12/16/2022, 4:21:43 AM
   */
  @Trace(operationName = "D2执行数据集数值相加与单数值比较(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSetSumOfSingleValueComparisonComRespDto implementDataSetSumOfSingleValueComparisonCom(ImplementDataSetSumOfSingleValueComparisonComReqDto reqDto){
    
      
      ImplementDataSetSumOfSingleValueComparisonAssemblyRespDto dataSetSumOfSingleValueComparisonRes_1 =null;
//步骤0: M2执行数据集数值相加与单数值比较（特殊方法） - implementDataSetSumOfSingleValueComparison
     //ModelCode: dataSetSumOfSingleValueComparison
        ImplementDataSetSumOfSingleValueComparisonAssemblyRespDto dataSetSumOfSingleValueComparisonRes = null;
    ImplementDataSetSumOfSingleValueComparisonAssemblyReqDto dataSetSumOfSingleValueComparisonReq=new ImplementDataSetSumOfSingleValueComparisonAssemblyReqDto();
  if(reqDto!=null){
      dataSetSumOfSingleValueComparisonReq.setDataSetSumOfSingleValueComparisonList(reqDto.getDataSetSumOfSingleValueComparisonList());//list-field-assign//sourceId:424047_1
      dataSetSumOfSingleValueComparisonReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:519320_1
    }
  
    /*M2执行数据集数值相加与单数值比较（特殊方法）[5154]  入参数据集与单数值，用数据集中每条记录的数值求和与数据集外的单数值进行比较 */
    Assert.isNull(dataSetSumOfSingleValueComparisonReq.getCalcPara2(),"D2执行数据集数值相加与单数值比较(公共)-M2执行数据集数值相加与单数值比较（特殊方法）-计算入参2不能为空",false);
      dataSetSumOfSingleValueComparisonRes = nbInterfaceMode.implementDataSetSumOfSingleValueComparisonAssembly(dataSetSumOfSingleValueComparisonReq);
      
      
      dataSetSumOfSingleValueComparisonRes_1 = dataSetSumOfSingleValueComparisonRes;
    
ImplementDataSetSumOfSingleValueComparisonComRespDto retData = new ImplementDataSetSumOfSingleValueComparisonComRespDto();
  if(dataSetSumOfSingleValueComparisonRes_1!=null){
      retData.setLogicalOperator(dataSetSumOfSingleValueComparisonRes_1.getLogicalOperator());//SimpleFieldAssign//sourceId:424052_1
    }
  

  
  
return retData;
  }
/**
   * D2计算数据集最大小值记录(公共)[5162]
   * gen by moon at 2/26/2023, 1:23:51 PM
   */
  @Trace(operationName = "D2计算数据集最大小值记录(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public CalculateDataBigMiniRecordComRespDto calculateDataBigMiniRecordCom(CalculateDataBigMiniRecordComReqDto reqDto){
    
      
      CalculateDataBigMiniRecordRespDto maxOrMinOfMultipleNumRes_1 =null;
//步骤0: M2计算数据集最大小值记录（特殊方法） - calculateDataBigMiniRecord
     //ModelCode: maxOrMinOfMultipleNum
        CalculateDataBigMiniRecordRespDto maxOrMinOfMultipleNumRes = null;
    CalculateDataBigMiniRecordReqDto maxOrMinOfMultipleNumReq=new CalculateDataBigMiniRecordReqDto();
  if(reqDto!= null&&  reqDto.getDataBigMiniRecordList() !=null&& !CollectionUtil.isEmpty(reqDto.getDataBigMiniRecordList())){
      maxOrMinOfMultipleNumReq.setDataMiniRecordList(reqDto.getDataBigMiniRecordList().stream().map(item -> BeanUtil.toBean(item, DataMiniRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:424428_1
    }
  if(reqDto!=null){
maxOrMinOfMultipleNumReq.setCalcMaxAndMin(reqDto.getCalcMaxAndMin());//SimpleFieldAssign//sourceId:424431_1
maxOrMinOfMultipleNumReq.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:703095_1
maxOrMinOfMultipleNumReq.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:703096_1
    }
  
    /*M2计算数据集最大小值记录（特殊方法）[5089]  用于求数据的最大或最小值。入参数据集+求最大或求最小标识 */
    Assert.isNull(maxOrMinOfMultipleNumReq.getCalcMaxAndMin(),"D2计算数据集最大小值记录(公共)-M2计算数据集最大小值记录（特殊方法）-求最大最小值不能为空",false);
      maxOrMinOfMultipleNumRes = nbInterfaceMode.calculateDataBigMiniRecord(maxOrMinOfMultipleNumReq);
      
      
      maxOrMinOfMultipleNumRes_1 = maxOrMinOfMultipleNumRes;
    
CalculateDataBigMiniRecordComRespDto retData = new CalculateDataBigMiniRecordComRespDto();
  if(maxOrMinOfMultipleNumRes_1!=null){
      retData.setContentID(maxOrMinOfMultipleNumRes_1.getContentID());//SimpleFieldAssign//sourceId:424434_1
retData.setOutputNum(maxOrMinOfMultipleNumRes_1.getOutputNum());//SimpleFieldAssign//sourceId:424435_1
    }
  

  
  
return retData;
  }
/**
   * D2-计算两个数值相减服务(公共)[5168]
   * gen by moon at 11/7/2022, 11:43:17 PM
   */
  @Trace(operationName = "D2-计算两个数值相减服务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public CalculateSubtractOfTwoNumComRespDto calculateSubtractOfTwoNumCom(CalculateSubtractOfTwoNumComReqDto reqDto){
    
      
      CalculateSubtractOfTwoNumComRespDto subtractionOfTwoNumRes_1 =null;
//步骤0: M2-计算两个数值相减(特殊方法) - calculateSubtractOfTwoNumCom
     //ModelCode: subtractionOfTwoNum
        CalculateSubtractOfTwoNumComRespDto subtractionOfTwoNumRes = null;
    CalculateSubtractOfTwoNumComReqDto subtractionOfTwoNumReq=new CalculateSubtractOfTwoNumComReqDto();
  if(reqDto!=null){
      subtractionOfTwoNumReq.setCalcPara1(reqDto.getCalcPara1());//SimpleFieldAssign//sourceId:425427_1
subtractionOfTwoNumReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:425428_1
    }
  
    /*M2-计算两个数值相减(特殊方法)[5167]  用户指标数据计算，入参两个数值，计算两数之差 */
    
      subtractionOfTwoNumRes = nbInterfaceMode.calculateSubtractOfTwoNumCom(subtractionOfTwoNumReq);
      
      
      subtractionOfTwoNumRes_1 = subtractionOfTwoNumRes;
    
CalculateSubtractOfTwoNumComRespDto retData = new CalculateSubtractOfTwoNumComRespDto();
  if(subtractionOfTwoNumRes_1!=null){
      retData.setCalcResult(subtractionOfTwoNumRes_1.getCalcResult());//SimpleFieldAssign//sourceId:425432_1
    }
  

  
  
return retData;
  }
/**
   * D2-执行统计数据集条数服务(公共)[5166]
   * gen by moon at 1/24/2023, 3:47:45 AM
   */
  @Trace(operationName = "D2-执行统计数据集条数服务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCountNumberDataSetsComRespDto implementCountNumberDataSetsCom(ImplementCountNumberDataSetsComReqDto reqDto){
    
      
      ImplementCountNumberDataSetsComRespDto getDataCountRes_1 =null;
//步骤0: M2-执行统计数据集条数(特殊方法) - implementCountNumberDataSetsCom
     //ModelCode: getDataCount
        ImplementCountNumberDataSetsComRespDto getDataCountRes = null;
    ImplementCountNumberDataSetsComReqDto getDataCountReq=new ImplementCountNumberDataSetsComReqDto();
  if(reqDto!= null&&  reqDto.getCountNumberDataSetsList() !=null&& !CollectionUtil.isEmpty(reqDto.getCountNumberDataSetsList())){
      getDataCountReq.setCountNumberDataSetsList(reqDto.getCountNumberDataSetsList().stream().map(item -> BeanUtil.toBean(item, CountNumberDataSetsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:424943_1
    }
  
    /*M2-执行统计数据集条数(特殊方法)[5165]  入参一个数据集，返回数据集条数 */
    
      getDataCountRes = nbInterfaceMode.implementCountNumberDataSetsCom(getDataCountReq);
      
      
      getDataCountRes_1 = getDataCountRes;
    
ImplementCountNumberDataSetsComRespDto retData = new ImplementCountNumberDataSetsComRespDto();
  if(getDataCountRes_1!=null){
      retData.setOutputNum(getDataCountRes_1.getOutputNum());//SimpleFieldAssign//sourceId:424946_1
    }
  

  
  
return retData;
  }
/**
   * D2-执行计算两个数值相除服务(公共)[5176]
   * gen by moon at 11/10/2022, 11:30:41 PM
   */
  @Trace(operationName = "D2-执行计算两个数值相除服务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDivisionOfTwoNumComRespDto implementDivisionOfTwoNumCom(ImplementDivisionOfTwoNumComReqDto reqDto){


      CalculateDivisionOfTwoNumComRespDto divisionOfTwoNumRes_1 =null;
//步骤0: M2-计算两个数值相除服务(特殊方法) - calculateDivisionOfTwoNumCom
     //ModelCode: divisionOfTwoNum
        CalculateDivisionOfTwoNumComRespDto divisionOfTwoNumRes = null;
    CalculateDivisionOfTwoNumComReqDto divisionOfTwoNumReq=new CalculateDivisionOfTwoNumComReqDto();
  if(reqDto!=null){
      divisionOfTwoNumReq.setCalcPara1(reqDto.getCalcPara1());//SimpleFieldAssign//sourceId:427542_1
divisionOfTwoNumReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:427543_1
    }

    /*M2-计算两个数值相除服务(特殊方法)[5175]   */

      divisionOfTwoNumRes = nbInterfaceMode.calculateDivisionOfTwoNumCom(divisionOfTwoNumReq);


      divisionOfTwoNumRes_1 = divisionOfTwoNumRes;

ImplementDivisionOfTwoNumComRespDto retData = new ImplementDivisionOfTwoNumComRespDto();
  if(divisionOfTwoNumRes_1!=null){
      retData.setCalcResult(divisionOfTwoNumRes_1.getCalcResult());//SimpleFieldAssign//sourceId:427547_1
    }




return retData;
  }
/**
   * D2-执行数据集计算完成数量(公共)[5176]
   * gen by moon at 11/12/2022, 12:34:37 AM
   */
  @Trace(operationName = "D2-执行数据集计算完成数量(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSetCountAchieveNumComRespDto implementDataSetCountAchieveNumCom(ImplementDataSetCountAchieveNumComReqDto reqDto){


      CalculateDataSetCountAchieveNumComRespDto getDataCountRes_1 =null;
//步骤0: M2-计算数据集计算完成数量(公共) - calculateDataSetCountAchieveNumCom
     //ModelCode: getDataCount
        CalculateDataSetCountAchieveNumComRespDto getDataCountRes = null;
    CalculateDataSetCountAchieveNumComReqDto getDataCountReq=new CalculateDataSetCountAchieveNumComReqDto();
  if(reqDto!=null){
      getDataCountReq.setCountAchieveNumdataSetList(reqDto.getCountAchieveNumdataSetList().stream().map(item -> BeanUtil.toBean(item, CountAchieveNumdataSetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:430052_1
    }

    /*M2-计算数据集计算完成数量(公共)[5175]  入参一个数据集，返回数据集条数 */

      getDataCountRes = nbInterfaceMode.calculateDataSetCountAchieveNumCom(getDataCountReq);


      getDataCountRes_1 = getDataCountRes;

ImplementDataSetCountAchieveNumComRespDto retData = new ImplementDataSetCountAchieveNumComRespDto();
  if(getDataCountRes_1!=null){
      retData.setAlreadyAccomplishNum(getDataCountRes_1.getAlreadyAccomplishNum());//SimpleFieldAssign//sourceId:430054_1
retData.setCalcCount(getDataCountRes_1.getCalcCount());//SimpleFieldAssign//sourceId:430055_1
    }




return retData;
  }
/**
   * D2判断条件值相等(公共)[5186]
   * gen by moon at 12/1/2022, 1:28:36 AM
   */
  @Trace(operationName = "D2判断条件值相等(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeConditionValueEqualComRespDto judgeConditionValueEqualCom(JudgeConditionValueEqualComReqDto reqDto){
    
      
      JudgeConditionValueEqualRespDto analyzesAllParaAreEqualRes_1 =null;
//步骤0: M2判断条件值相等（特殊方法） - judgeConditionValueEqual
     //ModelCode: analyzesAllParaAreEqual
        JudgeConditionValueEqualRespDto analyzesAllParaAreEqualRes = null;
    JudgeConditionValueEqualReqDto analyzesAllParaAreEqualReq=new JudgeConditionValueEqualReqDto();
  if(reqDto!=null){
      analyzesAllParaAreEqualReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:460891_1
analyzesAllParaAreEqualReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:460892_1
    }
  
    /*M2判断条件值相等（特殊方法）[5185]   */
    Assert.isNull(analyzesAllParaAreEqualReq.getCustomField1(),"D2判断条件值相等(公共)-M2判断条件值相等（特殊方法）-自定义字段1不能为空",false);
Assert.isNull(analyzesAllParaAreEqualReq.getCustomField2(),"D2判断条件值相等(公共)-M2判断条件值相等（特殊方法）-自定义字段2不能为空",false);
      analyzesAllParaAreEqualRes = nbInterfaceMode.judgeConditionValueEqual(analyzesAllParaAreEqualReq);
      
      
      analyzesAllParaAreEqualRes_1 = analyzesAllParaAreEqualRes;
    
JudgeConditionValueEqualComRespDto retData = new JudgeConditionValueEqualComRespDto();
  if(analyzesAllParaAreEqualRes_1!=null){
      retData.setEndValue(analyzesAllParaAreEqualRes_1.getEndValue());//SimpleFieldAssign//sourceId:432676_1
    }
  

  
  
return retData;
  }
/**
   * D2判断生命周期操作(公共)[5184]
   * gen by moon at 4/21/2023, 4:56:31 PM
   */
  @Trace(operationName = "D2判断生命周期操作(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeLifecycleActionsComRespDto judgeLifecycleActionsCom(JudgeLifecycleActionsComReqDto reqDto){
    
      
      ObtainReceiveFieldsRespDto receptionServiceRes_2 =null;
ObtainReceiveFieldsRespDto receptionServiceRes_4 =null;
ObtainReceiveFieldsRespDto receptionServiceRes_6 =null;
//virtualUsage M2-接收字段生命周期操作类型  21550
      //ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes = null;
    ObtainReceiveFieldsReqDto receptionServiceReq=new ObtainReceiveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq.setLifecyCycleOperationType(reqDto.getLifecyCycleOperationType());//SimpleFieldAssign//sourceId:431659_1_21550
    }
  
    /*M2-接收字段生命周期操作类型[4007]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getLifecyCycleOperationType(),"D2判断生命周期操作(公共)-M2-接收字段生命周期操作类型-生命周期操作类型不能为空",false);
      receptionServiceRes = nbInterfaceMode.obtainReceiveFields(receptionServiceReq);
      
      
      
if((reqDto!= null&&  reqDto.getLifecyCycleOperationType() !=null && reqDto.getLifecyCycleOperationType().equals("DELETE"))) {
        //if(D2判断生命周期操作(公共).生命周期操作类型 等于 删除)  21551

//ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes_1 = null;
    ObtainReceiveFieldsReqDto receptionServiceReq_1=new ObtainReceiveFieldsReqDto();
  receptionServiceReq_1.setSubjectLifeCycle("EDITING");//sourceId:431660_1_37685
  
    /*M2-约定删除的主体生命周期为正在编辑[4007]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getSubjectLifeCycle(),"D2判断生命周期操作(公共)-M2-约定删除的主体生命周期为正在编辑-主体生命周期不能为空",false);
      receptionServiceRes_1 = nbInterfaceMode.obtainReceiveFields(receptionServiceReq_1);
      
      
      receptionServiceRes_2 = receptionServiceRes_1;
      }
else if((reqDto!= null&&  reqDto.getLifecyCycleOperationType() !=null && reqDto.getLifecyCycleOperationType().equals("ARCHIVE"))){
       //elseif(D2判断生命周期操作(公共).生命周期操作类型 等于 存档)  21553
      
//ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes_3 = null;
    ObtainReceiveFieldsReqDto receptionServiceReq_2=new ObtainReceiveFieldsReqDto();
  receptionServiceReq_2.setArchivngType("NOT_ARCHIVE");//sourceId:431662_1_21556
receptionServiceReq_2.setIsArchive("FALSE");//sourceId:431663_1_21556
  
    /*M2-约定想存档状态[4007]  用于特殊方法接收上游入参。 */
    
      receptionServiceRes_3 = nbInterfaceMode.obtainReceiveFields(receptionServiceReq_2);
      
      
      receptionServiceRes_4 = receptionServiceRes_3;
    }
else if((reqDto!= null&&  reqDto.getLifecyCycleOperationType() !=null && reqDto.getLifecyCycleOperationType().equals("UNDO_ARCHIVE"))){
       //elseif(D2判断生命周期操作(公共).生命周期操作类型 等于 撤销存档)  21554

//ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes_5 = null;
    ObtainReceiveFieldsReqDto receptionServiceReq_3=new ObtainReceiveFieldsReqDto();
  receptionServiceReq_3.setArchivngType("TOBE_ARCHIVING");//sourceId:431666_1_21557
receptionServiceReq_3.setIsArchive("FALSE");//sourceId:431667_1_21557

    /*M2-约定撤销存档状态[4007]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getArchivngType(),"D2判断生命周期操作(公共)-M2-约定撤销存档状态-存档类型不能为空",false);
Assert.isNull(receptionServiceReq_3.getIsArchive(),"D2判断生命周期操作(公共)-M2-约定撤销存档状态-是否存档不能为空",false);
      receptionServiceRes_5 = nbInterfaceMode.obtainReceiveFields(receptionServiceReq_3);


      receptionServiceRes_6 = receptionServiceRes_5;
    }
JudgeLifecycleActionsComRespDto retData = new JudgeLifecycleActionsComRespDto();
  if(receptionServiceRes_4!=null){
      retData.setArchivngType(receptionServiceRes_4.getArchivngType());//SimpleFieldAssign//sourceId:431671_1
retData.setIsArchive(receptionServiceRes_4.getIsArchive());//SimpleFieldAssign//sourceId:431672_1
    }
if(receptionServiceRes_6!=null){
      retData.setArchivngType(receptionServiceRes_6.getArchivngType());//SimpleFieldAssign//sourceId:431671_1
retData.setIsArchive(receptionServiceRes_6.getIsArchive());//SimpleFieldAssign//sourceId:431672_1
    }
if(receptionServiceRes_2!=null){
      retData.setSubjectLifeCycle(receptionServiceRes_2.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:431673_1
    }
  

  
  
return retData;
  }
/**
   * D2执行取排序列表中上一条数据服务(公共)[5236]
   * gen by moon at 11/20/2022, 11:12:35 PM
   */
  @Trace(operationName = "D2执行取排序列表中上一条数据服务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementGetLastFromDataListComRespDto implementGetLastFromDataListCom(ImplementGetLastFromDataListComReqDto reqDto){


      QueryGetLastFromDataListDetailComRespDto getLastFromDataListRes_1 =null;
//步骤0: M2取排序列表中上一条数据(特殊方法) - queryGetLastFromDataListDetailCom
     //ModelCode: getLastFromDataList
        QueryGetLastFromDataListDetailComRespDto getLastFromDataListRes = null;
    QueryGetLastFromDataListDetailComReqDto getLastFromDataListReq=new QueryGetLastFromDataListDetailComReqDto();
  if(reqDto!= null&&  reqDto.getGetLastFromDataSpecifiedList() !=null&& !CollectionUtil.isEmpty(reqDto.getGetLastFromDataSpecifiedList())){
      getLastFromDataListReq.setGetLastFromDataSpecifiedList(reqDto.getGetLastFromDataSpecifiedList().stream().map(item -> BeanUtil.toBean(item, GetLastFromDataSpecifiedDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:443416_1
    }
if(reqDto!=null){
      getLastFromDataListReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:445057_1
getLastFromDataListReq.setOrderSizeType(reqDto.getOrderSizeType());//SimpleFieldAssign//sourceId:443417_1
    }

    /*M2取排序列表中上一条数据(特殊方法)[5235]  入参数据集，字段（主键ID）。数据集按排序字段已经排序，根据入参字段，找到数据集中的上一条记录 */

      getLastFromDataListRes = nbInterfaceMode.queryGetLastFromDataListDetailCom(getLastFromDataListReq);


      getLastFromDataListRes_1 = getLastFromDataListRes;

ImplementGetLastFromDataListComRespDto retData = new ImplementGetLastFromDataListComRespDto();
  if(getLastFromDataListRes_1!= null){
      retData.setCommPrimaryKey(getLastFromDataListRes_1.getCommPrimaryKey());//SimpleFieldAssign//sourceId:443421_1
    }




return retData;
  }
/**
   * D2执行多数据集取并集(公共)[5320]
   * gen by moon at 4/2/2023, 2:53:48 PM
   */
  @Trace(operationName = "D2执行多数据集取并集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsCom(ImplementUnionMultipleDataSetsComReqDto reqDto){
    
      
      ImplementUnionMultipleDataSetsRespDto collectionsMergeDataRes_1 =null;
//步骤0: M2执行多数据集取并集（特殊方法） - implementUnionMultipleDataSets
     //ModelCode: collectionsMergeData
        ImplementUnionMultipleDataSetsRespDto collectionsMergeDataRes = null;
    ImplementUnionMultipleDataSetsReqDto collectionsMergeDataReq=new ImplementUnionMultipleDataSetsReqDto();
  if(reqDto!= null&&  reqDto.getDataSetsListOne() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())){
      collectionsMergeDataReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:462931_1
    }
if(reqDto!= null&&  reqDto.getDataSetsListTwo() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())){
      collectionsMergeDataReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:462932_1
    }
  
    /*M2执行多数据集取并集（特殊方法）[5319]  入参多个数据集，取并集 */
    
      collectionsMergeDataRes = nbInterfaceMode.implementUnionMultipleDataSets(collectionsMergeDataReq);
      
      
      collectionsMergeDataRes_1 = collectionsMergeDataRes;
    
ImplementUnionMultipleDataSetsComRespDto retData = new ImplementUnionMultipleDataSetsComRespDto();
  if(collectionsMergeDataRes_1!=null){
      retData.setUnionMultipleDataSetsList(collectionsMergeDataRes_1.getUnionMultipleDataSetsList().stream().map(item -> BeanUtil.toBean(item, UnionMultipleDataSetsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:462936_1
    }


  
  
return retData;
  }
/**
   * D2-获取内存中业务字段(公共)[5343]
   * gen by moon at 12/3/2022, 4:35:09 PM
   */
  @Trace(operationName = "D2-获取内存中业务字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainGetPublicFieldCacheComRespDto obtainGetPublicFieldCacheCom(ObtainGetPublicFieldCacheComReqDto reqDto){
    
      
      ObtainGetPublicFieldCacheRespDto getPublicFieldCacheRes_1 =null;
//步骤0: M2-获取内存中业务字段（特殊方法） - obtainGetPublicFieldCache
     //ModelCode: getPublicFieldCache
        ObtainGetPublicFieldCacheRespDto getPublicFieldCacheRes = null;
    ObtainGetPublicFieldCacheReqDto getPublicFieldCacheReq=new ObtainGetPublicFieldCacheReqDto();
  
  
    /*M2-获取内存中业务字段（特殊方法）[5342]  用于定时任务/接口执行时，获取执行所需的缓存中业务字段信息，供定时任务/接口中虚拟用况使用 */
    
      getPublicFieldCacheRes = nbInterfaceMode.obtainGetPublicFieldCache(getPublicFieldCacheReq);
      
      
      getPublicFieldCacheRes_1 = getPublicFieldCacheRes;
    
ObtainGetPublicFieldCacheComRespDto retData = new ObtainGetPublicFieldCacheComRespDto();
  if(getPublicFieldCacheRes_1!=null){
      retData.setTargetCycleContentTypeCode(getPublicFieldCacheRes_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:465549_1
retData.setTargetCycleContentId(getPublicFieldCacheRes_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:465550_1
retData.setReportType(getPublicFieldCacheRes_1.getReportType());//SimpleFieldAssign//sourceId:465554_1
retData.setReportManagementModel(getPublicFieldCacheRes_1.getReportManagementModel());//SimpleFieldAssign//sourceId:465555_1
retData.setIsOpenCustomReport(getPublicFieldCacheRes_1.getIsOpenCustomReport());//SimpleFieldAssign//sourceId:465641_1
retData.setCycleId(getPublicFieldCacheRes_1.getCycleId());//SimpleFieldAssign//sourceId:465551_1
retData.setCycleTypeCode(getPublicFieldCacheRes_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:465645_1
retData.setCycleStartTime(getPublicFieldCacheRes_1.getCycleStartTime());//SimpleFieldAssign//sourceId:465552_1
retData.setCycleEndTime(getPublicFieldCacheRes_1.getCycleEndTime());//SimpleFieldAssign//sourceId:465553_1
retData.setLastCycleType(getPublicFieldCacheRes_1.getLastCycleType());//SimpleFieldAssign//sourceId:465611_1
retData.setFatherCycleType(getPublicFieldCacheRes_1.getFatherCycleType());//SimpleFieldAssign//sourceId:465612_1
retData.setMidCycleType(getPublicFieldCacheRes_1.getMidCycleType());//SimpleFieldAssign//sourceId:465613_1
retData.setSubcycleType(getPublicFieldCacheRes_1.getSubcycleType());//SimpleFieldAssign//sourceId:465614_1
retData.setIrregularCycleType(getPublicFieldCacheRes_1.getIrregularCycleType());//SimpleFieldAssign//sourceId:465615_1
retData.setTargetId(getPublicFieldCacheRes_1.getTargetId());//SimpleFieldAssign//sourceId:465556_1
retData.setEvaluationTemplateId(getPublicFieldCacheRes_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:465557_1
retData.setSpaceId(getPublicFieldCacheRes_1.getSpaceId());//SimpleFieldAssign//sourceId:465558_1
retData.setSubjectiveScorePoint(getPublicFieldCacheRes_1.getSubjectiveScorePoint());//SimpleFieldAssign//sourceId:468823_1
retData.setDecimalDigitsLastRules(getPublicFieldCacheRes_1.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:468824_1
retData.setCurSubjectiveScoreWeight(getPublicFieldCacheRes_1.getCurSubjectiveScoreWeight());//SimpleFieldAssign//sourceId:468825_1
retData.setProcessSubjectiveScoreWeight(getPublicFieldCacheRes_1.getProcessSubjectiveScoreWeight());//SimpleFieldAssign//sourceId:468826_1
retData.setSubjectiveScoreCountRule(getPublicFieldCacheRes_1.getSubjectiveScoreCountRule());//SimpleFieldAssign//sourceId:469012_1
retData.setDecimalPointRules(getPublicFieldCacheRes_1.getDecimalPointRules());//SimpleFieldAssign//sourceId:469869_1
retData.setWeightDecimalPoint(getPublicFieldCacheRes_1.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:470647_1
retData.setDegreeDecimalPoint(getPublicFieldCacheRes_1.getDegreeDecimalPoint());//SimpleFieldAssign//sourceId:470648_1
retData.setProgressDecimalPoint(getPublicFieldCacheRes_1.getProgressDecimalPoint());//SimpleFieldAssign//sourceId:470649_1
retData.setTargetValueType(getPublicFieldCacheRes_1.getTargetValueType());//SimpleFieldAssign//sourceId:470717_1
retData.setTargetDivisionSame(getPublicFieldCacheRes_1.getTargetDivisionSame());//SimpleFieldAssign//sourceId:470718_1
retData.setLevelNumber(getPublicFieldCacheRes_1.getLevelNumber());//SimpleFieldAssign//sourceId:470719_1
retData.setQuantityObjectiveNoValue(getPublicFieldCacheRes_1.getQuantityObjectiveNoValue());//SimpleFieldAssign//sourceId:471187_1
retData.setIsSubjectiveScoring(getPublicFieldCacheRes_1.getIsSubjectiveScoring());//SimpleFieldAssign//sourceId:471481_1
retData.setSubjectiveRatingTotalValueUnit(getPublicFieldCacheRes_1.getSubjectiveRatingTotalValueUnit());//SimpleFieldAssign//sourceId:472364_1
retData.setSubjectiveRatingTotalValue(getPublicFieldCacheRes_1.getSubjectiveRatingTotalValue());//SimpleFieldAssign//sourceId:472365_1
retData.setReportObjectSetCode(getPublicFieldCacheRes_1.getReportObjectSetCode());//SimpleFieldAssign//sourceId:472366_1
retData.setReportObjectSetCode(getPublicFieldCacheRes_1.getReportObjectSetCode());//SimpleFieldAssign//sourceId:472367_1
retData.setIsParentCycle(getPublicFieldCacheRes_1.getIsParentCycle());//SimpleFieldAssign//sourceId:473044_1
retData.setIsSubCycle(getPublicFieldCacheRes_1.getIsSubCycle());//SimpleFieldAssign//sourceId:473045_1
retData.setIsMetaphase(getPublicFieldCacheRes_1.getIsMetaphase());//SimpleFieldAssign//sourceId:473046_1
retData.setIsProcessCycleStage(getPublicFieldCacheRes_1.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:473047_1
retData.setIsDefinedExecuteCycleStage(getPublicFieldCacheRes_1.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:473048_1
retData.setSchemeDataPara(getPublicFieldCacheRes_1.getSchemeDataPara());//SimpleFieldAssign//sourceId:482868_1
    }
  

  
  
return retData;
  }
/**
   * D2执行两数据集去除已存在(公共)[5347]
   * gen by moon at 2/8/2023, 2:21:11 PM
   */
  @Trace(operationName = "D2执行两数据集去除已存在(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTwoDataRemovalExistsComRespDto implementTwoDataRemovalExistsCom(ImplementTwoDataRemovalExistsComReqDto reqDto){
    
      
      ImplementTwoDataRemovalExistsComRespDto collectionRemoveExistingDataRes_1 =null;
//步骤0: M2执行两数据集去除已存在（特殊方法） - implementTwoDataRemovalExists
     //ModelCode: collectionRemoveExistingData
        ImplementTwoDataRemovalExistsComRespDto collectionRemoveExistingDataRes = null;
    ImplementTwoDataRemovalExistsComReqDto collectionRemoveExistingDataReq=new ImplementTwoDataRemovalExistsComReqDto();
  if(reqDto!= null&&  reqDto.getDataSetsListOne() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())){
      collectionRemoveExistingDataReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:465569_1
    }
if(reqDto!= null&&  reqDto.getDataSetsListTwo() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())){
      collectionRemoveExistingDataReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:465570_1
    }
  
    /*M2执行两数据集去除已存在（特殊方法）[5345]  入参两个数据集，通过已存在标识字段匹配，去除第一个数据集中已存在的第二个数据集的数据 */
    
      collectionRemoveExistingDataRes = nbInterfaceMode.implementTwoDataRemovalExistsCom(collectionRemoveExistingDataReq);
      
      
      collectionRemoveExistingDataRes_1 = collectionRemoveExistingDataRes;
    
ImplementTwoDataRemovalExistsComRespDto retData = new ImplementTwoDataRemovalExistsComRespDto();
  if(collectionRemoveExistingDataRes_1!=null){
      retData.setTwoDataRemovalExistsList(collectionRemoveExistingDataRes_1.getTwoDataRemovalExistsList().stream().map(item -> BeanUtil.toBean(item, TwoDataRemovalExistsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:465622_1
    }
  

  
  
return retData;
  }
/**
   * D2执行入参时间点获取两个月时间点(公共)[5340]
   * gen by moon at 5/27/2023, 10:12:14 PM
   */
  @Trace(operationName = "D2执行入参时间点获取两个月时间点(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementInputTimePointGetTwoTimePointsComRespDto implementInputTimePointGetTwoTimePointsCom(ImplementInputTimePointGetTwoTimePointsComReqDto reqDto){
    
      
      ObtainReceiveFieldsRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getCustomField1() !=null && reqDto.getCustomField1().equals("POSTPONE_REPORT"))) {
        //if(D2执行入参时间点获取两个月时间点(公共).节假日处理策略配置答案值 等于 推迟汇报)  43268

     //ModelCode: findStartTimeOfCurMonAndEndTimeOfNextMon
        ImplementGetTwoTimePointsRespDto findStartTimeOfCurMonAndEndTimeOfNextMonRes = null;
    ImplementGetTwoTimePointsReqDto findStartTimeOfCurMonAndEndTimeOfNextMonReq=new ImplementGetTwoTimePointsReqDto();
  if(reqDto!=null){
      findStartTimeOfCurMonAndEndTimeOfNextMonReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:465579_1_43269
    }
  
    /*M2-执行入参时间点获取当前及下一个月时间点（特殊方法）[5338]  入参时间字段A，根据A字段的时间，查找所在当前月，以及下个月。返回当前月的开始时间+下个月的结束时间 */
    Assert.isNull(findStartTimeOfCurMonAndEndTimeOfNextMonReq.getComTimeField(),"D2执行入参时间点获取两个月时间点(公共)-M2-执行入参时间点获取当前及下一个月时间点（特殊方法）-通用时间字段不能为空",false);
      findStartTimeOfCurMonAndEndTimeOfNextMonRes = nbInterfaceMode.implementGetTwoTimePoints(findStartTimeOfCurMonAndEndTimeOfNextMonReq);
      
      

//ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes = null;
    ObtainReceiveFieldsReqDto receptionServiceReq=new ObtainReceiveFieldsReqDto();
  if(findStartTimeOfCurMonAndEndTimeOfNextMonRes!=null){
      receptionServiceReq.setCycleStartTime(findStartTimeOfCurMonAndEndTimeOfNextMonRes.getCycleStartTime());//SimpleFieldAssign//sourceId:987834_1_43272
receptionServiceReq.setCycleEndTime(findStartTimeOfCurMonAndEndTimeOfNextMonRes.getCycleEndTime());//SimpleFieldAssign//sourceId:987835_1_43272
    }

    /*约定字段：周期开始时间、周期结束时间[4007]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCycleStartTime(),"D2执行入参时间点获取两个月时间点(公共)-约定字段：周期开始时间、周期结束时间-周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getCycleEndTime(),"D2执行入参时间点获取两个月时间点(公共)-约定字段：周期开始时间、周期结束时间-周期结束时间不能为空",false);
      receptionServiceRes = nbInterfaceMode.obtainReceiveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((reqDto!= null&&  reqDto.getCustomField1() !=null && reqDto.getCustomField1().equals("ADVANCE_REPORT"))){
       //elseif(D2执行入参时间点获取两个月时间点(公共).节假日处理策略配置答案值 等于 提前汇报)  43270
    
//ModelCode: findStartTimeOfCurMonAndEndTimeOfForwardMon
        ImplementInputTimePointGetForwordTwoTimePointsRespDto findStartTimeOfCurMonAndEndTimeOfForwardMonRes = null;
    ImplementInputTimePointGetForwordTwoTimePointsReqDto findStartTimeOfCurMonAndEndTimeOfForwardMonReq=new ImplementInputTimePointGetForwordTwoTimePointsReqDto();
  if(reqDto!=null){
      findStartTimeOfCurMonAndEndTimeOfForwardMonReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:987840_1_43271
    }

    /*M2-执行入参时间点获取当前及前一个月时间点（特殊方法）[6974]  入参时间字段A，根据A字段的时间，查找所在当前月，以及上个个月。返回上个月的开始时间+当前月的结束时间 */
    Assert.isNull(findStartTimeOfCurMonAndEndTimeOfForwardMonReq.getComTimeField(),"D2执行入参时间点获取两个月时间点(公共)-M2-执行入参时间点获取当前及前一个月时间点（特殊方法）-通用时间字段不能为空",false);
      findStartTimeOfCurMonAndEndTimeOfForwardMonRes = nbInterfaceMode.implementInputTimePointGetForwordTwoTimePoints(findStartTimeOfCurMonAndEndTimeOfForwardMonReq);



//ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes_2 = null;
    ObtainReceiveFieldsReqDto receptionServiceReq_1=new ObtainReceiveFieldsReqDto();
  if(findStartTimeOfCurMonAndEndTimeOfForwardMonRes!=null){
      receptionServiceReq_1.setCycleStartTime(findStartTimeOfCurMonAndEndTimeOfForwardMonRes.getCycleStartTime());//SimpleFieldAssign//sourceId:987834_1_43273
receptionServiceReq_1.setCycleEndTime(findStartTimeOfCurMonAndEndTimeOfForwardMonRes.getCycleEndTime());//SimpleFieldAssign//sourceId:987835_1_43273
    }

    /*约定字段：周期开始时间、周期结束时间[4007]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCycleStartTime(),"D2执行入参时间点获取两个月时间点(公共)-约定字段：周期开始时间、周期结束时间-周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq_1.getCycleEndTime(),"D2执行入参时间点获取两个月时间点(公共)-约定字段：周期开始时间、周期结束时间-周期结束时间不能为空",false);
      receptionServiceRes_2 = nbInterfaceMode.obtainReceiveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
    }
ImplementInputTimePointGetTwoTimePointsComRespDto retData = new ImplementInputTimePointGetTwoTimePointsComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setCycleStartTime(receptionServiceRes_1.getCycleStartTime());//SimpleFieldAssign//sourceId:987847_1
retData.setCycleEndTime(receptionServiceRes_1.getCycleEndTime());//SimpleFieldAssign//sourceId:987848_1
    }
  

  
  
return retData;
  }
/**
   * D2执行入参时间匹配记录(公共)[5351]
   * gen by moon at 12/2/2022, 10:21:29 PM
   */
  @Trace(operationName = "D2执行入参时间匹配记录(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementMatchRecordInputTimePointComRespDto implementMatchRecordInputTimePointCom(ImplementMatchRecordInputTimePointComReqDto reqDto){
    
      
      MatchRecordInputTimePointComRespDto matchRecordBySpecRecRes_1 =null;
//步骤0: M2执行入参时间匹配记录（特殊方法） - implementMatchRecordInputTimePoint
     //ModelCode: matchRecordBySpecRec
        MatchRecordInputTimePointComRespDto matchRecordBySpecRecRes = null;
    MatchRecordInputTimePointComReqDto matchRecordBySpecRecReq=new MatchRecordInputTimePointComReqDto();
  if(reqDto!=null){
      matchRecordBySpecRecReq.setMatchRecordInputTimePointList(reqDto.getMatchRecordInputTimePointList().stream().map(item -> BeanUtil.toBean(item, MatchRecordInputTimePointDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:465975_1
matchRecordBySpecRecReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:465976_1
    }
  
    /*M2执行入参时间匹配记录（特殊方法）[5350]  入参数据集+单字段。通过入参单字段到数据集中查询指定同名字段值相同的所有记录 */
    Assert.isNull(matchRecordBySpecRecReq.getComTimeField(),"D2执行入参时间匹配记录(公共)-M2执行入参时间匹配记录（特殊方法）-通用时间字段不能为空",false);
      matchRecordBySpecRecRes = nbInterfaceMode.matchRecordInputTimePointCom(matchRecordBySpecRecReq);
      
      
      matchRecordBySpecRecRes_1 = matchRecordBySpecRecRes;
    
ImplementMatchRecordInputTimePointComRespDto retData = new ImplementMatchRecordInputTimePointComRespDto();
  if(matchRecordBySpecRecRes_1!=null){
      retData.setCustomField(matchRecordBySpecRecRes_1.getCustomField());//SimpleFieldAssign//sourceId:466027_1
retData.setComTimeField(matchRecordBySpecRecRes_1.getComTimeField());//SimpleFieldAssign//sourceId:466028_1
    }
  

  
  
return retData;
  }
/**
   * D2执行两点时间段天数(公共)[5353]
   * gen by moon at 12/2/2022, 10:21:35 PM
   */
  @Trace(operationName = "D2执行两点时间段天数(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTwoPointTimePeriodDaysComRespDto implementTwoPointTimePeriodDaysCom(ImplementTwoPointTimePeriodDaysComReqDto reqDto){
    
      
      TwoPointTimePeriodDaysComRespDto twoPointTimePeriodDaysRes_1 =null;
//步骤0: M2执行两点时间段天数（特殊方法） - implementTwoPointTimePeriodDays
     //ModelCode: twoPointTimePeriodDays
        TwoPointTimePeriodDaysComRespDto twoPointTimePeriodDaysRes = null;
    TwoPointTimePeriodDaysComReqDto twoPointTimePeriodDaysReq=new TwoPointTimePeriodDaysComReqDto();
  if(reqDto!=null){
      twoPointTimePeriodDaysReq.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:465998_1
twoPointTimePeriodDaysReq.setComTimeField2(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:465999_1
twoPointTimePeriodDaysReq.setTwoPointTimePeriodType(reqDto.getTwoPointTimePeriodType());//SimpleFieldAssign//sourceId:466008_1
    }
  
    /*M2执行两点时间段天数（特殊方法）[5352]   */
    Assert.isNull(twoPointTimePeriodDaysReq.getComTimeField1(),"D2执行两点时间段天数(公共)-M2执行两点时间段天数（特殊方法）-通用时间字段1不能为空",false);
Assert.isNull(twoPointTimePeriodDaysReq.getComTimeField2(),"D2执行两点时间段天数(公共)-M2执行两点时间段天数（特殊方法）-通用时间字段2不能为空",false);
Assert.isNull(twoPointTimePeriodDaysReq.getTwoPointTimePeriodType(),"D2执行两点时间段天数(公共)-M2执行两点时间段天数（特殊方法）-两点时间段含头尾类型不能为空",false);
      twoPointTimePeriodDaysRes = nbInterfaceMode.twoPointTimePeriodDaysCom(twoPointTimePeriodDaysReq);
      
      
      twoPointTimePeriodDaysRes_1 = twoPointTimePeriodDaysRes;
    
ImplementTwoPointTimePeriodDaysComRespDto retData = new ImplementTwoPointTimePeriodDaysComRespDto();
  if(twoPointTimePeriodDaysRes_1!=null){
      retData.setCalcCount(twoPointTimePeriodDaysRes_1.getCalcCount());//SimpleFieldAssign//sourceId:466003_1
    }
  

  
  
return retData;
  }
/**
   * D2执行时间点区间内前后偏移N天(公共)[5356]
   * gen by moon at 3/3/2023, 11:28:58 PM
   */
  @Trace(operationName = "D2执行时间点区间内前后偏移N天(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementOffsetNdaysInTimePointIntervalComRespDto implementOffsetNdaysInTimePointIntervalCom(ImplementOffsetNdaysInTimePointIntervalComReqDto reqDto){
    
      
      OffsetNdaysInTimePointIntervalComRespDto offsetNDaysInTimePointIntervalRes_1 =null;
//步骤0: M2执行时间点区间内前后偏移N天（特殊方法） - implementOffsetNdaysInTimePointInterval
     //ModelCode: offsetNDaysInTimePointInterval
        OffsetNdaysInTimePointIntervalComRespDto offsetNDaysInTimePointIntervalRes = null;
    OffsetNdaysInTimePointIntervalComReqDto offsetNDaysInTimePointIntervalReq=new OffsetNdaysInTimePointIntervalComReqDto();
  if(reqDto!=null){
      offsetNDaysInTimePointIntervalReq.setNumCompareResult(reqDto.getNumCompareResult());//SimpleFieldAssign//sourceId:466503_1
offsetNDaysInTimePointIntervalReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:466505_1
offsetNDaysInTimePointIntervalReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:468303_1
    }
if(reqDto!= null&&  reqDto.getOffsetNdaysInTimePointIntervalList() !=null&& !CollectionUtil.isEmpty(reqDto.getOffsetNdaysInTimePointIntervalList())){
      offsetNDaysInTimePointIntervalReq.setOffsetNdaysInTimePointIntervalList(reqDto.getOffsetNdaysInTimePointIntervalList().stream().map(item -> BeanUtil.toBean(item, OffsetNdaysInTimePointIntervalDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:466504_1
    }
  
    /*M2执行时间点区间内前后偏移N天（特殊方法）[5355]   */
    Assert.isNull(offsetNDaysInTimePointIntervalReq.getNumCompareResult(),"D2执行时间点区间内前后偏移N天(公共)-M2执行时间点区间内前后偏移N天（特殊方法）-数值比较结果不能为空",false);
Assert.isNull(offsetNDaysInTimePointIntervalReq.getComTimeField(),"D2执行时间点区间内前后偏移N天(公共)-M2执行时间点区间内前后偏移N天（特殊方法）-通用时间字段不能为空",false);
Assert.isNull(offsetNDaysInTimePointIntervalReq.getComNumField(),"D2执行时间点区间内前后偏移N天(公共)-M2执行时间点区间内前后偏移N天（特殊方法）-通用数值字段（整数型）不能为空",false);
      offsetNDaysInTimePointIntervalRes = nbInterfaceMode.offsetNdaysInTimePointIntervalCom(offsetNDaysInTimePointIntervalReq);
      
      
      offsetNDaysInTimePointIntervalRes_1 = offsetNDaysInTimePointIntervalRes;
    
ImplementOffsetNdaysInTimePointIntervalComRespDto retData = new ImplementOffsetNdaysInTimePointIntervalComRespDto();
  if(offsetNDaysInTimePointIntervalRes_1!=null){
      retData.setCustomField(offsetNDaysInTimePointIntervalRes_1.getCustomField());//SimpleFieldAssign//sourceId:466512_1
retData.setComTimeField(offsetNDaysInTimePointIntervalRes_1.getComTimeField());//SimpleFieldAssign//sourceId:466513_1
    }
  

  
  
return retData;
  }
/**
   * D2执行分析自然日数据集(公共)[5377]
   * gen by moon at 12/4/2022, 6:46:28 PM
   */
  @Trace(operationName = "D2执行分析自然日数据集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyzeNaturalDayDataComRespDto implementAnalyzeNaturalDayDataCom(ImplementAnalyzeNaturalDayDataComReqDto reqDto){


      AnalyzeNaturalDayDataComRespDto analyzeNaturalDayDataRes_1 =null;
//步骤0: M2执行分析自然日数据集（特殊方法） - implementAnalyzeNaturalDayData
     //ModelCode: analyzeNaturalDayData
        AnalyzeNaturalDayDataComRespDto analyzeNaturalDayDataRes = null;
    AnalyzeNaturalDayDataComReqDto analyzeNaturalDayDataReq=new AnalyzeNaturalDayDataComReqDto();
  if(reqDto!=null){
      analyzeNaturalDayDataReq.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:482536_1
analyzeNaturalDayDataReq.setComTimeField2(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:482537_1
analyzeNaturalDayDataReq.setTwoPointTimePeriodType(reqDto.getTwoPointTimePeriodType());//SimpleFieldAssign//sourceId:486868_1
    }

    /*M2执行分析自然日数据集（特殊方法）[5376]  入参开始时间，结束时间，输出数据集。计算开始和结束时间内的所有自然日（包含开始和结束两天） */
    Assert.isNull(analyzeNaturalDayDataReq.getComTimeField1(),"D2执行分析自然日数据集(公共)-M2执行分析自然日数据集（特殊方法）-通用时间字段1不能为空",false);
Assert.isNull(analyzeNaturalDayDataReq.getComTimeField2(),"D2执行分析自然日数据集(公共)-M2执行分析自然日数据集（特殊方法）-通用时间字段2不能为空",false);
Assert.isNull(analyzeNaturalDayDataReq.getTwoPointTimePeriodType(),"D2执行分析自然日数据集(公共)-M2执行分析自然日数据集（特殊方法）-两点时间段含头尾类型不能为空",false);
      analyzeNaturalDayDataRes = nbInterfaceMode.analyzeNaturalDayDataCom(analyzeNaturalDayDataReq);


      analyzeNaturalDayDataRes_1 = analyzeNaturalDayDataRes;

ImplementAnalyzeNaturalDayDataComRespDto retData = new ImplementAnalyzeNaturalDayDataComRespDto();
  if(analyzeNaturalDayDataRes_1!=null){
      retData.setAnalyzeNaturalDayDataList(analyzeNaturalDayDataRes_1.getAnalyzeNaturalDayDataList().stream().map(item -> BeanUtil.toBean(item, AnalyzeNaturalDayDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:482541_1
    }




return retData;
  }
/**
   * D2-执行计算时间范围服务(公共)[5409]
   * gen by moon at 5/7/2023, 12:57:07 PM
   */
  @Trace(operationName = "D2-执行计算时间范围服务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCountTimeScopeServiceComRespDto implementCountTimeScopeServiceCom(ImplementCountTimeScopeServiceComReqDto reqDto){


      ImplementCountTimeScopeServiceComRespDto getTimeRangeRes_1 =null;
//步骤0: M2执行计算时间范围服务(公共) - implementCountTimeScopeServiceCom
     //ModelCode: getTimeRange
        ImplementCountTimeScopeServiceComRespDto getTimeRangeRes = null;
    ImplementCountTimeScopeServiceComReqDto getTimeRangeReq=new ImplementCountTimeScopeServiceComReqDto();
if(reqDto!=null){
      getTimeRangeReq.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:489915_1
      getTimeRangeReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:489914_1
getTimeRangeReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:489913_1
    }

    /*M2执行计算时间范围服务(公共)[5408]  入参：数量，当前时间，数量单位（默认年）。逻辑：当前时间+数量（年）出参：开始时间（当前时间），结束时间（计算后的时间） */
    Assert.isNull(getTimeRangeReq.getComTimeField1(),"D2-执行计算时间范围服务(公共)-M2执行计算时间范围服务(公共)-通用时间字段1不能为空",false);
Assert.isNull(getTimeRangeReq.getComNumField(),"D2-执行计算时间范围服务(公共)-M2执行计算时间范围服务(公共)-通用数值字段（整数型）不能为空",false);
Assert.isNull(getTimeRangeReq.getCycleTypeCode(),"D2-执行计算时间范围服务(公共)-M2执行计算时间范围服务(公共)-周期类型标识不能为空",false);
      getTimeRangeRes = nbInterfaceMode.implementCountTimeScopeServiceCom(getTimeRangeReq);


      getTimeRangeRes_1 = getTimeRangeRes;

ImplementCountTimeScopeServiceComRespDto retData = new ImplementCountTimeScopeServiceComRespDto();
  if(getTimeRangeRes_1!=null){
      retData.setStartTime(getTimeRangeRes_1.getStartTime());//SimpleFieldAssign//sourceId:489920_1
retData.setEndTime(getTimeRangeRes_1.getEndTime());//SimpleFieldAssign//sourceId:489921_1
    }




return retData;
  }
/**
   * D2执行数据集减一条记录(公共)[5415]
   * gen by moon at 12/7/2022, 10:24:16 PM
   */
  @Trace(operationName = "D2执行数据集减一条记录(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSubtractOneComRespDto implementDataSubtractOneCom(ImplementDataSubtractOneComReqDto reqDto){


      ImplementDataSubtractOneRespDto dataFilterSpecRecByRes_1 =null;
//步骤0: M2执行数据集减一条记录（特殊方法） - implementDataSubtractOne
     //ModelCode: dataFilterSpecRecBy
        ImplementDataSubtractOneRespDto dataFilterSpecRecByRes = null;
    ImplementDataSubtractOneReqDto dataFilterSpecRecByReq=new ImplementDataSubtractOneReqDto();
  if(reqDto!=null){
      dataFilterSpecRecByReq.setDataSubtractOneList(reqDto.getDataSubtractOneList());//list-field-assign//sourceId:490876_1
dataFilterSpecRecByReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:490877_1
    }

    /*M2执行数据集减一条记录（特殊方法）[5414]  目前用于购物车步骤判断。入参：步骤数据集+三个步骤字段（字段名与数据集中步骤编码相同）
处理逻辑：入参步骤字段值不为1，则将数据集中步骤编码同名的记录从出参数据集中删除 */
    Assert.isNull(dataFilterSpecRecByReq.getCustomField(),"D2执行数据集减一条记录(公共)-M2执行数据集减一条记录（特殊方法）-自定义字段不能为空",false);
      dataFilterSpecRecByRes = nbInterfaceMode.implementDataSubtractOne(dataFilterSpecRecByReq);


      dataFilterSpecRecByRes_1 = dataFilterSpecRecByRes;

ImplementDataSubtractOneComRespDto retData = new ImplementDataSubtractOneComRespDto();
  if(dataFilterSpecRecByRes_1!=null){
      retData.setDataSubtractOneList(dataFilterSpecRecByRes_1.getDataSubtractOneList());//list-field-assign//sourceId:490886_1
    }




return retData;
  }
/**
   * D2执行数据集按入参过滤指定记录服务(公共)[5477]
   * gen by moon at 3/18/2023, 3:21:06 PM
   */
  @Trace(operationName = "D2执行数据集按入参过滤指定记录服务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataFilterSpecRecByComRespDto implementDataFilterSpecRecByCom(ImplementDataFilterSpecRecByComReqDto reqDto){


      ImplementDataFilterSpecRecByComRespDto dataFilterSpecRecByRes_1 =null;
//步骤0: M2执行数据集按入参过滤指定记录(公共) - implementDataFilterSpecRecByCom
     //ModelCode: dataFilterSpecRecBy
        ImplementDataFilterSpecRecByComRespDto dataFilterSpecRecByRes = null;
    ImplementDataFilterSpecRecByComReqDto dataFilterSpecRecByReq=new ImplementDataFilterSpecRecByComReqDto();
  if(reqDto!= null&&  reqDto.getDataFilterSpecRecByList() !=null&& !CollectionUtil.isEmpty(reqDto.getDataFilterSpecRecByList())){
      dataFilterSpecRecByReq.setDataFilterSpecRecByList(reqDto.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:520774_1
    }
  if(reqDto!=null){
      dataFilterSpecRecByReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:726385_1
dataFilterSpecRecByReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:520775_1
dataFilterSpecRecByReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:766232_1
    }

    /*M2执行数据集按入参过滤指定记录(公共)[5478]  目前用于购物车步骤判断。入参：步骤数据集+三个步骤字段（字段名与数据集中步骤编码相同）
处理逻辑：入参步骤字段值不为1，则将数据集中步骤编码同名的记录从出参数据集中删除 */

      dataFilterSpecRecByRes = nbInterfaceMode.implementDataFilterSpecRecByCom(dataFilterSpecRecByReq);


      dataFilterSpecRecByRes_1 = dataFilterSpecRecByRes;

ImplementDataFilterSpecRecByComRespDto retData = new ImplementDataFilterSpecRecByComRespDto();
  if(dataFilterSpecRecByRes_1!=null){
      retData.setDataFilterSpecRecByList(dataFilterSpecRecByRes_1.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:520791_1
    }




return retData;
  }
/**
   * D2执行两个数值对比大小(公共)[5551]
       * gen by moon at 12/30/2022, 6:27:45 PM
   */
  @Trace(operationName = "D2执行两个数值对比大小(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeCom(ImplementNumericalContrastMagnitudeComReqDto reqDto){


      ImplementNumericalContrastMagnitudeRespDto numericalSizeComparisonRes_1 =null;
//步骤0: M2执行两个数值对比大小（特殊方法） - implementNumericalContrastMagnitude
     //ModelCode: numericalSizeComparison
        ImplementNumericalContrastMagnitudeRespDto numericalSizeComparisonRes = null;
    ImplementNumericalContrastMagnitudeReqDto numericalSizeComparisonReq=new ImplementNumericalContrastMagnitudeReqDto();
  if(reqDto!=null){
      numericalSizeComparisonReq.setCalcPara1(reqDto.getCalcPara1());//SimpleFieldAssign//sourceId:553853_1
numericalSizeComparisonReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:553852_1
    }

    /*M2执行两个数值对比大小（特殊方法）[4132]  入参A，B两个数值型参数，对比大小。A与B比较，输出大于、等于、小于 */
    Assert.isNull(numericalSizeComparisonReq.getCalcPara1(),"D2执行两个数值对比大小(公共)-M2执行两个数值对比大小（特殊方法）-计算入参1不能为空",false);
Assert.isNull(numericalSizeComparisonReq.getCalcPara2(),"D2执行两个数值对比大小(公共)-M2执行两个数值对比大小（特殊方法）-计算入参2不能为空",false);
      numericalSizeComparisonRes = nbInterfaceMode.implementNumericalContrastMagnitude(numericalSizeComparisonReq);


      numericalSizeComparisonRes_1 = numericalSizeComparisonRes;

ImplementNumericalContrastMagnitudeComRespDto retData = new ImplementNumericalContrastMagnitudeComRespDto();
  if(numericalSizeComparisonRes_1!=null){
      retData.setNumCompareResult(numericalSizeComparisonRes_1.getNumCompareResult());//SimpleFieldAssign//sourceId:553857_1
    }




return retData;
  }
/**
   * D2-执行按类型过滤数据集(公共)[5599]
   * gen by moon at 5/27/2024, 7:28:58 PM
   */
  @Trace(operationName = "D2-执行按类型过滤数据集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataFilterSpecRecByTypeCodeComRespDto implementDataFilterSpecRecByTypeCodeCom(ImplementDataFilterSpecRecByTypeCodeComReqDto reqDto){


      ImplementDataFilterSpecRecByTypeCodeRespDto dataFilterSpecRecByTypeCodeRes_1 =null;
//步骤0: M2-执行按类型过滤数据集（特殊方法） - implementDataFilterSpecRecByTypeCode
     //ModelCode: dataFilterSpecRecByTypeCode
        ImplementDataFilterSpecRecByTypeCodeRespDto dataFilterSpecRecByTypeCodeRes = null;
    ImplementDataFilterSpecRecByTypeCodeReqDto dataFilterSpecRecByTypeCodeReq=new ImplementDataFilterSpecRecByTypeCodeReqDto();
  if(reqDto!= null&&  reqDto.getDataFilterSpecRecByTypeCodeList() !=null&& !CollectionUtil.isEmpty(reqDto.getDataFilterSpecRecByTypeCodeList())){
      dataFilterSpecRecByTypeCodeReq.setDataFilterSpecRecByTypeCodeList(reqDto.getDataFilterSpecRecByTypeCodeList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByTypeCodeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:577780_1
    }
  if(reqDto!=null){
dataFilterSpecRecByTypeCodeReq.setComCode(reqDto.getComCode());//SimpleFieldAssign//sourceId:577781_1
    }

    /*M2-执行按类型过滤数据集（特殊方法）[5598]  入参数据集（主键+类型等字段）+类型A，按入参的类型A字段过滤数据集，返回类型等于A的数据集 */
    Assert.isNull(dataFilterSpecRecByTypeCodeReq.getComCode(),"D2-执行按类型过滤数据集(公共)-M2-执行按类型过滤数据集（特殊方法）-通用编码标识不能为空",false);
      dataFilterSpecRecByTypeCodeRes = nbInterfaceMode.implementDataFilterSpecRecByTypeCode(dataFilterSpecRecByTypeCodeReq);


      dataFilterSpecRecByTypeCodeRes_1 = dataFilterSpecRecByTypeCodeRes;

ImplementDataFilterSpecRecByTypeCodeComRespDto retData = new ImplementDataFilterSpecRecByTypeCodeComRespDto();
  if(dataFilterSpecRecByTypeCodeRes_1!=null){
      retData.setDataFilterSpecRecByTypeCodeList(dataFilterSpecRecByTypeCodeRes_1.getDataFilterSpecRecByTypeCodeList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByTypeCodeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:577785_1
    }




return retData;
  }
/**
   * D2执行获取上级非末级的下发状态(公共)[5641]
   * gen by moon at 1/10/2023, 10:46:43 PM
   */
  @Trace(operationName = "D2执行获取上级非末级的下发状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementGainSuperiorNotLastIssueStateComRespDto implementGainSuperiorNotLastIssueStateCom(ImplementGainSuperiorNotLastIssueStateComReqDto reqDto){


      ImplementGainSuperiorNotLastIssueStateComRespDto gainIssueStateRes_1 =null;
//步骤0: M2执行获取上级非末级的下发状态(公共) - implementGainSuperiorNotLastIssueStateCom
     //ModelCode: gainIssueState
        ImplementGainSuperiorNotLastIssueStateComRespDto gainIssueStateRes = null;
    ImplementGainSuperiorNotLastIssueStateComReqDto gainIssueStateReq=new ImplementGainSuperiorNotLastIssueStateComReqDto();
  if(reqDto!= null&&  reqDto.getSuperiorTargetObjAssistNodeStatusListList() !=null&& !CollectionUtil.isEmpty(reqDto.getSuperiorTargetObjAssistNodeStatusListList())){
      gainIssueStateReq.setSuperiorTargetObjAssistNodeStatusListList(reqDto.getSuperiorTargetObjAssistNodeStatusListList().stream().map(item -> BeanUtil.toBean(item, SuperiorTargetObjAssistNodeStatusListDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:597368_1
    }
if(reqDto!= null&&  reqDto.getSubordinateTargetObjAssistNodeStatusList() !=null&& !CollectionUtil.isEmpty(reqDto.getSubordinateTargetObjAssistNodeStatusList())){
      gainIssueStateReq.setSubordinateTargetObjAssistNodeStatusList(reqDto.getSubordinateTargetObjAssistNodeStatusList().stream().map(item -> BeanUtil.toBean(item, SubordinateTargetObjAssistNodeStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:597363_1
    }

    /*M2执行获取上级非末级的下发状态(公共)[5638]  入参上级目标内容数据集及下级目标内容节点状态，获取上级目标内容下发状态 */

      gainIssueStateRes = nbInterfaceMode.implementGainSuperiorNotLastIssueStateCom(gainIssueStateReq);


      gainIssueStateRes_1 = gainIssueStateRes;

ImplementGainSuperiorNotLastIssueStateComRespDto retData = new ImplementGainSuperiorNotLastIssueStateComRespDto();
  if(gainIssueStateRes_1!=null){
      retData.setTargetContGainIssueStateList(gainIssueStateRes_1.getTargetContGainIssueStateList().stream().map(item -> BeanUtil.toBean(item, TargetContGainIssueStateDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:597381_1
    }




return retData;
  }
/**
   * D2执行多数据集多字段取并集(公共)[5649]
   * gen by moon at 1/11/2023, 5:04:57 AM
   */
  @Trace(operationName = "D2执行多数据集多字段取并集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementUnionMultipleManyFieldsDataSetsComRespDto implementUnionMultipleManyFieldsDataSetsCom(ImplementUnionMultipleManyFieldsDataSetsComReqDto reqDto){


      ImplementUnionMultipleManyFieldsDataSetsRespDto collectionsMergeDataRes_1 =null;
//步骤0: M2执行多数据集多字段取并集（特殊方法） - implementUnionMultipleManyFieldsDataSets
     //ModelCode: collectionsMergeData
        ImplementUnionMultipleManyFieldsDataSetsRespDto collectionsMergeDataRes = null;
    ImplementUnionMultipleManyFieldsDataSetsReqDto collectionsMergeDataReq=new ImplementUnionMultipleManyFieldsDataSetsReqDto();
  if(reqDto!= null&&  reqDto.getDataSetsListOne() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())){
      collectionsMergeDataReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:598067_1
    }
if(reqDto!= null&&  reqDto.getDataSetsListTwo() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())){
      collectionsMergeDataReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:598068_1
    }

    /*M2执行多数据集多字段取并集（特殊方法）[5648]  入参多个数据集，取并集 */

      collectionsMergeDataRes = nbInterfaceMode.implementUnionMultipleManyFieldsDataSets(collectionsMergeDataReq);


      collectionsMergeDataRes_1 = collectionsMergeDataRes;

ImplementUnionMultipleManyFieldsDataSetsComRespDto retData = new ImplementUnionMultipleManyFieldsDataSetsComRespDto();
  if(collectionsMergeDataRes_1!=null){
      retData.setUnionMultipleDataSetsList(collectionsMergeDataRes_1.getUnionMultipleDataSetsList().stream().map(item -> BeanUtil.toBean(item, UnionMultipleDataSetsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:598090_1
    }




return retData;
  }
/**
   * D2执行获取非分工目标内容下发状态(公共)[5643]
   * gen by moon at 1/11/2023, 5:05:06 AM
   */
  @Trace(operationName = "D2执行获取非分工目标内容下发状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementGainNotDivTargetContIssueStateComRespDto implementGainNotDivTargetContIssueStateCom(ImplementGainNotDivTargetContIssueStateComReqDto reqDto){


      ImplementGainNotDivTargetContIssueStateRespDto singleDatasetObjMergeRes_1 =null;
//步骤0: M2执行获取非分工目标内容下发状态 - implementGainNotDivTargetContIssueState
     //ModelCode: singleDatasetObjMerge
        ImplementGainNotDivTargetContIssueStateRespDto singleDatasetObjMergeRes = null;
    ImplementGainNotDivTargetContIssueStateReqDto singleDatasetObjMergeReq=new ImplementGainNotDivTargetContIssueStateReqDto();
  singleDatasetObjMergeReq.setComTxtField("TRUE");//CUSTOM_CONVENTION//sourceId:597500_1
if(reqDto!=null){
      singleDatasetObjMergeReq.setSuperiorTargetObjAssistNodeStatusListList(reqDto.getSuperiorTargetObjAssistNodeStatusListList());//list-field-assign//sourceId:597499_1
    }

    /*M2执行获取非分工目标内容下发状态[5642]   */
    Assert.isNull(singleDatasetObjMergeReq.getComTxtField(),"D2执行获取非分工目标内容下发状态(公共)-M2执行获取非分工目标内容下发状态-通用文本字段不能为空",false);
      singleDatasetObjMergeRes = nbInterfaceMode.implementGainNotDivTargetContIssueState(singleDatasetObjMergeReq);


      singleDatasetObjMergeRes_1 = singleDatasetObjMergeRes;

ImplementGainNotDivTargetContIssueStateComRespDto retData = new ImplementGainNotDivTargetContIssueStateComRespDto();
  if(singleDatasetObjMergeRes_1!=null){
      retData.setTargetContGainIssueStateList(singleDatasetObjMergeRes_1.getTargetContGainIssueStateList().stream().map(item -> BeanUtil.toBean(item, TargetContGainIssueStateDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:597507_1
    }




return retData;
  }
/**
   * D2执行多数据集多字段取交集(公共)[5676]
   * gen by moon at 2/8/2023, 1:49:03 PM
   */
  @Trace(operationName = "D2执行多数据集多字段取交集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementUniteMultipleManyFieldsDataSetsComRespDto implementUniteMultipleManyFieldsDataSetsCom(ImplementUniteMultipleManyFieldsDataSetsComReqDto reqDto){


      ImplementUniteMultipleManyFieldsDataSetsRespDto collectionsIntersectionsDataRes_1 =null;
//步骤0: M2执行多数据集多字段取交集（特殊方法） - implementUniteMultipleManyFieldsDataSets
     //ModelCode: collectionsIntersectionsData
        ImplementUniteMultipleManyFieldsDataSetsRespDto collectionsIntersectionsDataRes = null;
    ImplementUniteMultipleManyFieldsDataSetsReqDto collectionsIntersectionsDataReq=new ImplementUniteMultipleManyFieldsDataSetsReqDto();
  if(reqDto!= null&&  reqDto.getDataSetsListOne() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())){
      collectionsIntersectionsDataReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:603502_1
    }
      if(reqDto!= null&&  reqDto.getDataSetsListTwo() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())){
      collectionsIntersectionsDataReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:603503_1
      }

    /*M2执行多数据集多字段取交集（特殊方法）[5675]  入参两个数据集，求两个数据集中共同存在的部分输出 */

      collectionsIntersectionsDataRes = nbInterfaceMode.implementUniteMultipleManyFieldsDataSets(collectionsIntersectionsDataReq);


      collectionsIntersectionsDataRes_1 = collectionsIntersectionsDataRes;

ImplementUniteMultipleManyFieldsDataSetsComRespDto retData = new ImplementUniteMultipleManyFieldsDataSetsComRespDto();
  if(collectionsIntersectionsDataRes_1!=null){
      retData.setCollectionsIntersectionsDataList(collectionsIntersectionsDataRes_1.getCollectionsIntersectionsDataList().stream().map(item -> BeanUtil.toBean(item, CollectionsIntersectionsDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:604010_1
    }




return retData;
  }
/**
   * D2执行数据集单条多字段列转行(公共)[5724]
   * gen by moon at 1/17/2023, 9:42:09 PM
   */
  @Trace(operationName = "D2执行数据集单条多字段列转行(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataEinzelbandFiltersColumnTurnRowComRespDto implementDataEinzelbandFiltersColumnTurnRowCom(ImplementDataEinzelbandFiltersColumnTurnRowComReqDto reqDto){


      ImplementDataEinzelbandFiltersColumnTurnRowRespDto columnToRowRes_1 =null;
//步骤0: M2执行数据集单条多字段列转行(特殊方法） - implementDataEinzelbandFiltersColumnTurnRow
     //ModelCode: columnToRow
        ImplementDataEinzelbandFiltersColumnTurnRowRespDto columnToRowRes = null;
    ImplementDataEinzelbandFiltersColumnTurnRowReqDto columnToRowReq=new ImplementDataEinzelbandFiltersColumnTurnRowReqDto();
  if(reqDto!=null){
      columnToRowReq.setDataEinzelbandFiltersColumnTurnRowList(reqDto.getDataEinzelbandFiltersColumnTurnRowList().stream().map(item -> BeanUtil.toBean(item, DataEinzelbandFiltersColumnTurnRowDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:614493_1
    }

    /*M2执行数据集单条多字段列转行(特殊方法）[5723]  将多列数据转成一行数据 */

      columnToRowRes = nbInterfaceMode.implementDataEinzelbandFiltersColumnTurnRow(columnToRowReq);


      columnToRowRes_1 = columnToRowRes;

ImplementDataEinzelbandFiltersColumnTurnRowComRespDto retData = new ImplementDataEinzelbandFiltersColumnTurnRowComRespDto();
  if(columnToRowRes_1!=null){
      retData.setCommPrimaryKey(columnToRowRes_1.getCommPrimaryKey());//SimpleFieldAssign//sourceId:614500_1
retData.setCustomField(columnToRowRes_1.getCustomField());//SimpleFieldAssign//sourceId:614501_1
retData.setCustomField1(columnToRowRes_1.getCustomField1());//SimpleFieldAssign//sourceId:614502_1
retData.setCustomField2(columnToRowRes_1.getCustomField2());//SimpleFieldAssign//sourceId:614503_1
retData.setCustomField3(columnToRowRes_1.getCustomField3());//SimpleFieldAssign//sourceId:614504_1
    }




return retData;
  }
/**
   * D2执行数据新增删除分类(公共)[5727]
   * gen by moon at 1/18/2023, 3:24:42 PM
   */
  @Trace(operationName = "D2执行数据新增删除分类(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataAddOrDeleteClassComRespDto implementDataAddOrDeleteClassCom(ImplementDataAddOrDeleteClassComReqDto reqDto){


      ImplementDataAddOrDeleteClassRespDto dataAuClassificationRes_1 =null;
//步骤0: M2执行数据新增删除分类（特殊方法） - implementDataAddOrDeleteClass
     //ModelCode: dataAuClassification
        ImplementDataAddOrDeleteClassRespDto dataAuClassificationRes = null;
    ImplementDataAddOrDeleteClassReqDto dataAuClassificationReq=new ImplementDataAddOrDeleteClassReqDto();
  if(reqDto!=null){
      dataAuClassificationReq.setDataSetsListOne(reqDto.getDataSetsListOne());//list-field-assign//sourceId:614571_1
dataAuClassificationReq.setDataSetsListTwo(reqDto.getDataSetsListTwo());//list-field-assign//sourceId:614572_1
    }

    /*M2执行数据新增删除分类（特殊方法）[5728]  入参两个数据集，出参两个数据集，分别对应：新增数据集、删除数据集 */

      dataAuClassificationRes = nbInterfaceMode.implementDataAddOrDeleteClass(dataAuClassificationReq);


      dataAuClassificationRes_1 = dataAuClassificationRes;

ImplementDataAddOrDeleteClassComRespDto retData = new ImplementDataAddOrDeleteClassComRespDto();
  if(dataAuClassificationRes_1!=null){
      retData.setAwaitAddClassDataList(dataAuClassificationRes_1.getAwaitAddClassDataList());//list-field-assign//sourceId:614577_1
retData.setAwaitDeleteClassDataList(dataAuClassificationRes_1.getAwaitDeleteClassDataList());//list-field-assign//sourceId:614578_1
    }




return retData;
  }
/**
   * D2-执行字符串对比(公共)[5774]
   * gen by moon at 5/9/2023, 5:19:41 AM
   */
  @Trace(operationName = "D2-执行字符串对比(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckCom(ImplementStringEfficiencyCheckComReqDto reqDto){


      ImplementStringEfficiencyCheckRespDto stringEfficiencyCheckRes_1 =null;
//步骤0: M2-执行字符串对比（特殊方法） - implementStringEfficiencyCheck
     //ModelCode: stringEfficiencyCheck
        ImplementStringEfficiencyCheckRespDto stringEfficiencyCheckRes = null;
    ImplementStringEfficiencyCheckReqDto stringEfficiencyCheckReq=new ImplementStringEfficiencyCheckReqDto();
  if(reqDto!=null){
      stringEfficiencyCheckReq.setReferenceString(reqDto.getReferenceString());//SimpleFieldAssign//sourceId:627983_1
stringEfficiencyCheckReq.setComparisonString(reqDto.getComparisonString());//SimpleFieldAssign//sourceId:627984_1
    }

    /*M2-执行字符串对比（特殊方法）[3423]  入参末级周期类型标识（参照字符串），当前周期类型标识（比对字符串），如果对比字符串等于参照字符串，则返回TRUE，否则返回FALSE */

      stringEfficiencyCheckRes = nbInterfaceMode.implementStringEfficiencyCheck(stringEfficiencyCheckReq);


      stringEfficiencyCheckRes_1 = stringEfficiencyCheckRes;

ImplementStringEfficiencyCheckComRespDto retData = new ImplementStringEfficiencyCheckComRespDto();
  if(stringEfficiencyCheckRes_1!=null){
      retData.setStringEfficiencyCheckResult(stringEfficiencyCheckRes_1.getStringEfficiencyCheckResult());//SimpleFieldAssign//sourceId:627988_1
    }




return retData;
  }
/**
   * D2-执行多条转数据集(公共)[5869]
   * gen by moon at 2/8/2023, 2:21:06 PM
   */
  @Trace(operationName = "D2-执行多条转数据集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementMulitDataToOneDatasComRespDto implementMulitDataToOneDatasCom(ImplementMulitDataToOneDatasComReqDto reqDto){


      ImplementMulitDataToOneDatasRespDto objectToDataRes_1 =null;
//步骤0: M2-执行多字段转数据集（特殊方法） - implementMulitDataToOneDatas
     //ModelCode: objectToData
        ImplementMulitDataToOneDatasRespDto objectToDataRes = null;
    ImplementMulitDataToOneDatasReqDto objectToDataReq=new ImplementMulitDataToOneDatasReqDto();
  if(reqDto!=null){
      objectToDataReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:657425_1
objectToDataReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:657426_1
objectToDataReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:657427_1
objectToDataReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:657428_1
objectToDataReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:657799_1
objectToDataReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:657800_1
    }

    /*M2-执行多字段转数据集（特殊方法）[5868]  用于周期阶段资料内容中查询的多个图片信息，数据库中一个字段中的信息将转换到多张图片信息的地址（数据集）供前端展示 */

      objectToDataRes = nbInterfaceMode.implementMulitDataToOneDatas(objectToDataReq);


      objectToDataRes_1 = objectToDataRes;

ImplementMulitDataToOneDatasComRespDto retData = new ImplementMulitDataToOneDatasComRespDto();
  if(objectToDataRes_1!=null){
      retData.setMulitDataToOneDatasList(objectToDataRes_1.getMulitDataToOneDatasList().stream().map(item -> BeanUtil.toBean(item, MulitDataToOneDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:657434_1
    }




return retData;
  }
/**
   * D2执行根据排序左右切数据(公共)[5866]
   * gen by moon at 2/10/2023, 9:43:07 PM
   */
  @Trace(operationName = "D2执行根据排序左右切数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSplitDataBySortComRespDto implementSplitDataBySortCom(ImplementSplitDataBySortComReqDto reqDto){


      ImplementSplitDataBySortRespDto findTargetDataByIntervalDataRes_1 =null;
//步骤0: M2执行根据排序左右切数据（特殊方法） - implementSplitDataBySort
     //ModelCode: findTargetDataByIntervalData
        ImplementSplitDataBySortRespDto findTargetDataByIntervalDataRes = null;
    ImplementSplitDataBySortReqDto findTargetDataByIntervalDataReq=new ImplementSplitDataBySortReqDto();
if(reqDto!=null){
      findTargetDataByIntervalDataReq.setComDatasList(reqDto.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:660492_1
findTargetDataByIntervalDataReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:660493_1
findTargetDataByIntervalDataReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:660494_1
    }

    /*M2执行根据排序左右切数据（特殊方法）[5865]  入参数据集+单字段数值+大小策略。出参数据集中满足条件的单条数据
单字段数值跟数据集中同名字段对比，根据策略（向上找大或向下找小）找到数据集中的记录。
举例：数据集里面有60，及格；70，一般；80，中等；90，良好；100，优秀
数据集集外的单字段是87，策略：向上找大
目的就是根据入参的单字段，到数据集里面找所在的数据区间，如果落在了80中等~90良好区间，则返回90良好 */
    Assert.isNull(findTargetDataByIntervalDataReq.getCustomField1(),"D2执行根据排序左右切数据(公共)-M2执行根据排序左右切数据（特殊方法）-自定义字段1不能为空",false);
Assert.isNull(findTargetDataByIntervalDataReq.getCustomField2(),"D2执行根据排序左右切数据(公共)-M2执行根据排序左右切数据（特殊方法）-自定义字段2不能为空",false);
      findTargetDataByIntervalDataRes = nbInterfaceMode.implementSplitDataBySort(findTargetDataByIntervalDataReq);


      findTargetDataByIntervalDataRes_1 = findTargetDataByIntervalDataRes;

ImplementSplitDataBySortComRespDto retData = new ImplementSplitDataBySortComRespDto();
  if(findTargetDataByIntervalDataRes_1!=null){
      retData.setComDatasList(findTargetDataByIntervalDataRes_1.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:657131_1
    }




return retData;
  }
/**
   * D2执行截取字符串保留前N个字符(公共)[5878]
   * gen by moon at 10/5/2023, 2:21:11 PM
   */
  @Trace(operationName = "D2执行截取字符串保留前N个字符(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCutRetainStringComRespDto implementCutRetainStringCom(ImplementCutRetainStringComReqDto reqDto){


      QueryCutRetainStringDetailRespDto cutStringRes_1 =null;
//步骤0: M2截取字符串保留前N个字符（特殊方法） - queryCutRetainStringDetail
     //ModelCode: cutString
        QueryCutRetainStringDetailRespDto cutStringRes = null;
    QueryCutRetainStringDetailReqDto cutStringReq=new QueryCutRetainStringDetailReqDto();
  if(reqDto!=null){
      cutStringReq.setOriginalString(reqDto.getOriginalString());//SimpleFieldAssign//sourceId:660978_1
cutStringReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:1162330_1
    }

    /*M2截取字符串保留前N个字符（特殊方法）[5877]  入参字符串A，数值B。用于从字符串A中截取前B个字符 */
    Assert.isNull(cutStringReq.getOriginalString(),"D2执行截取字符串保留前N个字符(公共)-M2截取字符串保留前N个字符（特殊方法）-原字符串不能为空",false);
Assert.isNull(cutStringReq.getComNumField(),"D2执行截取字符串保留前N个字符(公共)-M2截取字符串保留前N个字符（特殊方法）-通用数值字段（整数型）不能为空",false);
      cutStringRes = nbInterfaceMode.queryCutRetainStringDetail(cutStringReq);


      cutStringRes_1 = cutStringRes;

ImplementCutRetainStringComRespDto retData = new ImplementCutRetainStringComRespDto();
  if(cutStringRes_1!=null){
      retData.setCutString(cutStringRes_1.getCutString());//SimpleFieldAssign//sourceId:660982_1
    }




return retData;
  }
/**
   * D2执行多条转数据集(公共)[5864]
   * gen by moon at 5/21/2024, 11:18:19 PM
   */
  @Trace(operationName = "D2执行多条转数据集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementMutDataToOneDatasComRespDto implementMutDataToOneDatasCom(ImplementMutDataToOneDatasComReqDto reqDto){


      ImplementMutDataToOneDatasRespDto objectToDataRes_1 =null;
//步骤0: M2执行多条转数据集（特殊方法） - implementMutDataToOneDatas
     //ModelCode: objectToData
        ImplementMutDataToOneDatasRespDto objectToDataRes = null;
    ImplementMutDataToOneDatasReqDto objectToDataReq=new ImplementMutDataToOneDatasReqDto();
  if(reqDto!=null){
      objectToDataReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:717755_1
      objectToDataReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:657040_1
objectToDataReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:657041_1
objectToDataReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:657042_1
objectToDataReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:701717_1
objectToDataReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:701718_1
objectToDataReq.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:701719_1
objectToDataReq.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:701720_1
objectToDataReq.setCustomField8(reqDto.getCustomField8());//SimpleFieldAssign//sourceId:701721_1
objectToDataReq.setCustomField9(reqDto.getCustomField9());//SimpleFieldAssign//sourceId:1812218_1
objectToDataReq.setCustomField10(reqDto.getCustomField10());//SimpleFieldAssign//sourceId:1812219_1
objectToDataReq.setCustomField11(reqDto.getCustomField11());//SimpleFieldAssign//sourceId:1812220_1
objectToDataReq.setCustomField12(reqDto.getCustomField12());//SimpleFieldAssign//sourceId:1812221_1
objectToDataReq.setCustomField13(reqDto.getCustomField13());//SimpleFieldAssign//sourceId:1812222_1
objectToDataReq.setCustomField14(reqDto.getCustomField14());//SimpleFieldAssign//sourceId:1812223_1
objectToDataReq.setCustomField15(reqDto.getCustomField15());//SimpleFieldAssign//sourceId:1812224_1
objectToDataReq.setCustomField16(reqDto.getCustomField16());//SimpleFieldAssign//sourceId:1812225_1
    }

    /*M2执行多条转数据集（特殊方法）[5863]  用于周期阶段资料内容中查询的多个图片信息，数据库中一个字段中的信息将转换到多张图片信息的地址（数据集）供前端展示 */

      objectToDataRes = nbInterfaceMode.implementMutDataToOneDatas(objectToDataReq);


      objectToDataRes_1 = objectToDataRes;

ImplementMutDataToOneDatasComRespDto retData = new ImplementMutDataToOneDatasComRespDto();
  if(objectToDataRes_1!=null){
      retData.setComDatasList(objectToDataRes_1.getComDatasList());//list-field-assign//sourceId:657047_1
    }




return retData;
  }
/**
   * D2执行文档数据集插入排序字段(公共)[6063]
   * gen by moon at 3/11/2023, 3:58:12 PM
   */
  @Trace(operationName = "D2执行文档数据集插入排序字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDocDataSetInsertionOrderNumComRespDto implementDocDataSetInsertionOrderNumCom(ImplementDocDataSetInsertionOrderNumComReqDto reqDto){


      ImplementDocDataSetInsertionOrderNumRespDto docDataSetInsertionOrderNumRes_1 =null;
//步骤0: M2执行文档数据集插入排序字段 - implementDocDataSetInsertionOrderNum
     //ModelCode: docDataSetInsertionOrderNum
        ImplementDocDataSetInsertionOrderNumRespDto docDataSetInsertionOrderNumRes = null;
    ImplementDocDataSetInsertionOrderNumReqDto docDataSetInsertionOrderNumReq=new ImplementDocDataSetInsertionOrderNumReqDto();
  if(reqDto!= null&&  reqDto.getDocumentList() !=null&& !CollectionUtil.isEmpty(reqDto.getDocumentList())){
      docDataSetInsertionOrderNumReq.setDocumentList(reqDto.getDocumentList().stream().map(item -> BeanUtil.toBean(item, DocumentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743730_1
    }

    /*M2执行文档数据集插入排序字段[6062]  个性模式：仅用于文档的数据集数据插入排序字段值 */

      docDataSetInsertionOrderNumRes = nbInterfaceMode.implementDocDataSetInsertionOrderNum(docDataSetInsertionOrderNumReq);


      docDataSetInsertionOrderNumRes_1 = docDataSetInsertionOrderNumRes;

ImplementDocDataSetInsertionOrderNumComRespDto retData = new ImplementDocDataSetInsertionOrderNumComRespDto();
  if(docDataSetInsertionOrderNumRes_1!=null){
      retData.setDocumentList(docDataSetInsertionOrderNumRes_1.getDocumentList().stream().map(item -> BeanUtil.toBean(item, DocumentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743733_1
    }




return retData;
  }
/**
   * D2执行数据集合并文档关系字段(公共)[6065]
   * gen by moon at 3/11/2023, 3:34:27 PM
   */
  @Trace(operationName = "D2执行数据集合并文档关系字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSetMergeDocRelationFieldsComRespDto implementDataSetMergeDocRelationFieldsCom(ImplementDataSetMergeDocRelationFieldsComReqDto reqDto){


      ImplementDataSetMergeDocRelationFieldsComRespDto dataSetMergeDocRelationFieldsRes_1 =null;
//步骤0: M2执行数据集合并文档关系字段(公共) - implementDataSetMergeDocRelationFieldsCom
     //ModelCode: dataSetMergeDocRelationFields
        ImplementDataSetMergeDocRelationFieldsComRespDto dataSetMergeDocRelationFieldsRes = null;
    ImplementDataSetMergeDocRelationFieldsComReqDto dataSetMergeDocRelationFieldsReq=new ImplementDataSetMergeDocRelationFieldsComReqDto();
  if(reqDto!= null&&  reqDto.getDocumentList() !=null&& !CollectionUtil.isEmpty(reqDto.getDocumentList())){
      dataSetMergeDocRelationFieldsReq.setDocumentList(reqDto.getDocumentList().stream().map(item -> BeanUtil.toBean(item, DocumentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743739_1
    }
if(reqDto!= null&&  reqDto.getDataSetsListOne() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())){
      dataSetMergeDocRelationFieldsReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743740_1
    }

    /*M2执行数据集合并文档关系字段(公共)[6064]  个性模式：仅用于文档数据集合并文档关系数据集中的字段 */

      dataSetMergeDocRelationFieldsRes = nbInterfaceMode.implementDataSetMergeDocRelationFieldsCom(dataSetMergeDocRelationFieldsReq);


      dataSetMergeDocRelationFieldsRes_1 = dataSetMergeDocRelationFieldsRes;

ImplementDataSetMergeDocRelationFieldsComRespDto retData = new ImplementDataSetMergeDocRelationFieldsComRespDto();
  if(dataSetMergeDocRelationFieldsRes_1!=null){
      retData.setDocumentList(dataSetMergeDocRelationFieldsRes_1.getDocumentList().stream().map(item -> BeanUtil.toBean(item, DocumentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743744_1
    }




return retData;
  }

/**
   * D2执行多数据集字段合并(公共)[6214]
   * gen by moon at 4/2/2023, 9:50:56 PM
   */
  @Trace(operationName = "D2执行多数据集字段合并(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementManyDataSetFieldsMergeComRespDto implementManyDataSetFieldsMergeCom(ImplementManyDataSetFieldsMergeComReqDto reqDto){


      ImplementManyDataSetFieldsMergeRespDto manyDataSetFieldsMergeRes_1 =null;
//步骤0: M2执行多数据集字段合并（特殊方法） - implementManyDataSetFieldsMerge
     //ModelCode: manyDataSetFieldsMerge
        ImplementManyDataSetFieldsMergeRespDto manyDataSetFieldsMergeRes = null;
    ImplementManyDataSetFieldsMergeReqDto manyDataSetFieldsMergeReq=new ImplementManyDataSetFieldsMergeReqDto();
  if(reqDto!= null&&  reqDto.getDataSetsListOne() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())){
      manyDataSetFieldsMergeReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:809141_1
    }
if(reqDto!= null&&  reqDto.getDataSetsListTwo() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())){
      manyDataSetFieldsMergeReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:809142_1
    }

    /*M2执行多数据集字段合并（特殊方法）[6213]  用于2个以上的数据集多字段合并成一个数据集并出参 */

      manyDataSetFieldsMergeRes = nbInterfaceMode.implementManyDataSetFieldsMerge(manyDataSetFieldsMergeReq);


      manyDataSetFieldsMergeRes_1 = manyDataSetFieldsMergeRes;

ImplementManyDataSetFieldsMergeComRespDto retData = new ImplementManyDataSetFieldsMergeComRespDto();
  if(manyDataSetFieldsMergeRes_1!=null){
      retData.setMergeFieldsList(manyDataSetFieldsMergeRes_1.getMergeFieldsList().stream().map(item -> BeanUtil.toBean(item, MergeFieldsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:809146_1
    }




return retData;
  }
/**
   * D2-执行标准时间转换为字符串(公共)[6274]
   * gen by moon at 4/15/2023, 1:05:18 AM
   */
  @Trace(operationName = "D2-执行标准时间转换为字符串(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTimeTurnToStringComRespDto implementTimeTurnToStringCom(ImplementTimeTurnToStringComReqDto reqDto){


      ImplementTimeTurnToStringRespDto timeTurnToStringRes_1 =null;
//步骤0: M2-执行标准时间转换为字符串（特殊接口） - implementTimeTurnToString
     //ModelCode: timeTurnToString
        ImplementTimeTurnToStringRespDto timeTurnToStringRes = null;
    ImplementTimeTurnToStringReqDto timeTurnToStringReq=new ImplementTimeTurnToStringReqDto();
  if(reqDto!=null){
      timeTurnToStringReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:822169_1
    }

    /*M2-执行标准时间转换为字符串（特殊接口）[6273]  入参标准时间字段2022-09-02 23:00:09，将时间字段转换为字符串20220902230009 */

      timeTurnToStringRes = nbInterfaceMode.implementTimeTurnToString(timeTurnToStringReq);


      timeTurnToStringRes_1 = timeTurnToStringRes;

ImplementTimeTurnToStringComRespDto retData = new ImplementTimeTurnToStringComRespDto();
  if(timeTurnToStringRes_1!=null){
      retData.setComTxtField(timeTurnToStringRes_1.getComTxtField());//SimpleFieldAssign//sourceId:822172_1
    }




return retData;
  }
/**
   * D2执行找祖先标识(公共)[6307]
   * gen by moon at 4/17/2023, 11:49:41 PM
   */
  @Trace(operationName = "D2执行找祖先标识(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLookAncestorNodeCodeComRespDto implementLookAncestorNodeCodeCom(ImplementLookAncestorNodeCodeComReqDto reqDto){


      QueryLookAncestorNodeCodeListRespDto findAllLevelCodeListRes_1 =null;
//步骤0: M2-查找祖先标识列表(特殊方法） - queryLookAncestorNodeCodeList
     //ModelCode: findAllLevelCodeList
        QueryLookAncestorNodeCodeListRespDto findAllLevelCodeListRes = null;
    QueryLookAncestorNodeCodeListReqDto findAllLevelCodeListReq=new QueryLookAncestorNodeCodeListReqDto();
  if(reqDto!=null){
      findAllLevelCodeListReq.setComCode(reqDto.getComCode());//SimpleFieldAssign//sourceId:837246_1
    }

    /*M2-查找祖先标识列表(特殊方法）[6308]  找入参条件的所有层级列表 */
    Assert.isNull(findAllLevelCodeListReq.getComCode(),"D2执行找祖先标识(公共)-M2-查找祖先标识列表(特殊方法）-通用编码标识不能为空",false);
      findAllLevelCodeListRes = nbInterfaceMode.queryLookAncestorNodeCodeList(findAllLevelCodeListReq);


      findAllLevelCodeListRes_1 = findAllLevelCodeListRes;

ImplementLookAncestorNodeCodeComRespDto retData = new ImplementLookAncestorNodeCodeComRespDto();
  if(findAllLevelCodeListRes_1!=null){
      retData.setLookAncestorNodeList(findAllLevelCodeListRes_1.getLookAncestorNodeList());//list-field-assign//sourceId:837248_1
    }




return retData;
  }
/**
   * D2执行两个值比较是否相等(公共)[6425]
   * gen by moon at 9/25/2023, 10:44:42 AM
   */
  @Trace(operationName = "D2执行两个值比较是否相等(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTwoValuesIsEqualityComRespDto implementTwoValuesIsEqualityCom(ImplementTwoValuesIsEqualityComReqDto reqDto){


      ImplementTwoValuesIsEqualityRespDto twoValuesIsEqualityRes_1 =null;
//步骤0: M2执行两个值比较是否相等(特殊方法） - implementTwoValuesIsEquality
     //ModelCode: twoValuesIsEquality
        ImplementTwoValuesIsEqualityRespDto twoValuesIsEqualityRes = null;
    ImplementTwoValuesIsEqualityReqDto twoValuesIsEqualityReq=new ImplementTwoValuesIsEqualityReqDto();
  if(reqDto!=null){
      twoValuesIsEqualityReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:879693_1
twoValuesIsEqualityReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:879694_1
    }

    /*M2执行两个值比较是否相等(特殊方法）[6427]  用于比较两个字段值是否相同 */

      twoValuesIsEqualityRes = nbInterfaceMode.implementTwoValuesIsEquality(twoValuesIsEqualityReq);


      twoValuesIsEqualityRes_1 = twoValuesIsEqualityRes;

ImplementTwoValuesIsEqualityComRespDto retData = new ImplementTwoValuesIsEqualityComRespDto();
  if(twoValuesIsEqualityRes_1!=null){
      retData.setTureOrFalse(twoValuesIsEqualityRes_1.getTureOrFalse());//SimpleFieldAssign//sourceId:879698_1
    }




return retData;
  }
/**
   * D2-执行周期合并(公共)[6506]
   * gen by moon at 5/28/2023, 11:13:44 PM
   */
  @Trace(operationName = "D2-执行周期合并(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementExcCycleSetFieldsMergeComRespDto implementExcCycleSetFieldsMergeCom(ImplementExcCycleSetFieldsMergeComReqDto reqDto){


      ImplementExcCycleSetFieldsMergeRespDto collectionsMergeDataRes_1 =null;
//步骤0: M2-执行周期合并（特殊方法） - implementExcCycleSetFieldsMerge
     //ModelCode: collectionsMergeData
        ImplementExcCycleSetFieldsMergeRespDto collectionsMergeDataRes = null;
    ImplementExcCycleSetFieldsMergeReqDto collectionsMergeDataReq=new ImplementExcCycleSetFieldsMergeReqDto();
  if(reqDto!=null){
      collectionsMergeDataReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:902142_1
collectionsMergeDataReq.setExcCycleSetFieldsMergeList(reqDto.getExcCycleSetFieldsMergeList().stream().map(item -> BeanUtil.toBean(item, ExcCycleSetFieldsMergeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:902144_1
    }

    /*M2-执行周期合并（特殊方法）[6505]  入参多个数据集，取并集 */

      collectionsMergeDataRes = nbInterfaceMode.implementExcCycleSetFieldsMerge(collectionsMergeDataReq);


      collectionsMergeDataRes_1 = collectionsMergeDataRes;

ImplementExcCycleSetFieldsMergeComRespDto retData = new ImplementExcCycleSetFieldsMergeComRespDto();
  if(collectionsMergeDataRes_1!=null){
      retData.setExecuteCycleStageList(collectionsMergeDataRes_1.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:902145_1
    }




return retData;
  }
/**
   * D2执行接收数据集出参(公共)[6523]
   * gen by moon at 5/8/2023, 6:57:20 AM
   */
  @Trace(operationName = "D2执行接收数据集出参(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAcceptDataSetOutputComRespDto implementAcceptDataSetOutputCom(ImplementAcceptDataSetOutputComReqDto reqDto){


      ImplementAcceptDataSetOutputRespDto receptionServiceRes_1 =null;
//步骤0: M2执行接收数据集出参（特殊方法） - implementAcceptDataSetOutput
     //ModelCode: receptionService
        ImplementAcceptDataSetOutputRespDto receptionServiceRes = null;
    ImplementAcceptDataSetOutputReqDto receptionServiceReq=new ImplementAcceptDataSetOutputReqDto();
  if(reqDto!=null){
      receptionServiceReq.setAcceptDataSetOutputList(//objList-to-objLists
        reqDto.getAcceptDataSetOutputList().stream().map(item -> {
      AcceptDataSetOutputDto elm = new AcceptDataSetOutputDto();
      if(item!=null){
      elm.setApplexRelId(item.getApplexRelId());//SimpleFieldAssign//sourceId:193292_2
elm.setApplexType(item.getApplObjType());//SimpleFieldAssign//sourceId:193293_2
elm.setApplexId(item.getApplexId());//SimpleFieldAssign//sourceId:193294_2
elm.setObjectName(item.getObjectName());//SimpleFieldAssign//sourceId:193295_2
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:904148_1
    }

    /*M2执行接收数据集出参（特殊方法）[6522]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbInterfaceMode.implementAcceptDataSetOutput(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;

ImplementAcceptDataSetOutputComRespDto retData = new ImplementAcceptDataSetOutputComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setAcceptDataSetOutputList(//objList-to-objLists
        receptionServiceRes_1.getAcceptDataSetOutputList().stream().map(item -> {
      AcceptDataSetOutputDto elm = new AcceptDataSetOutputDto();
      if(item!=null){
      elm.setApplexRelId(item.getApplexRelId());//SimpleFieldAssign//sourceId:193300_2
elm.setApplObjType(item.getApplexType());//SimpleFieldAssign//sourceId:193301_2
elm.setApplexId(item.getApplexId());//SimpleFieldAssign//sourceId:193302_2
elm.setObjectName(item.getObjectName());//SimpleFieldAssign//sourceId:193303_2
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:904151_1
    }




return retData;
  }
/**
   * D2查询整数型变量详情(公共)[6531]
   * gen by moon at 1/21/2024, 9:48:13 PM
   */
  @Trace(operationName = "D2查询整数型变量详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryIntegerVariableDetailComRespDto queryIntegerVariableDetailCom(QueryIntegerVariableDetailComReqDto reqDto){


      ObtainReceiveFieldsRespDto receptionServiceRes_1 =null;
//步骤0: M2获取接收字段 - obtainReceiveFields
     //ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes = null;
    ObtainReceiveFieldsReqDto receptionServiceReq=new ObtainReceiveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq.setObjectName(reqDto.getObjectName());//SimpleFieldAssign//sourceId:1110530_1
receptionServiceReq.setMsgChannelClassCode(reqDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1475848_1
receptionServiceReq.setChannelName(reqDto.getChannelName());//SimpleFieldAssign//sourceId:1110531_1
receptionServiceReq.setChannelLogo(reqDto.getChannelLogo());//SimpleFieldAssign//sourceId:1110532_1
receptionServiceReq.setNewTableTypeCode(reqDto.getNewTableTypeCode());//SimpleFieldAssign//sourceId:1110533_1
receptionServiceReq.setNewEntityId(reqDto.getNewEntityId());//SimpleFieldAssign//sourceId:1110534_1
receptionServiceReq.setConTableTypeCode(reqDto.getConTableTypeCode());//SimpleFieldAssign//sourceId:1442572_1
receptionServiceReq.setConEntityId(reqDto.getConEntityId());//SimpleFieldAssign//sourceId:1442573_1
      receptionServiceReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:908034_1
receptionServiceReq.setMessageTemplateCode(reqDto.getMessageTemplateCode());//SimpleFieldAssign//sourceId:1108762_1
receptionServiceReq.setUseChannelMethod(reqDto.getUseChannelMethod());//SimpleFieldAssign//sourceId:1102390_1
receptionServiceReq.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1110535_1
receptionServiceReq.setChannelAppCliqueType(reqDto.getChannelAppCliqueType());//SimpleFieldAssign//sourceId:1442101_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1110536_1
receptionServiceReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1442583_1
receptionServiceReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1442632_1
receptionServiceReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1442633_1
receptionServiceReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:1442652_1
receptionServiceReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1442619_1
receptionServiceReq.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1442606_1
receptionServiceReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1442607_1
receptionServiceReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:1443710_1
receptionServiceReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:1443711_1
receptionServiceReq.setMediaType(reqDto.getMediaType());//SimpleFieldAssign//sourceId:1442884_1
receptionServiceReq.setMediaAddress(reqDto.getMediaAddress());//SimpleFieldAssign//sourceId:1442885_1
receptionServiceReq.setCooperateContentTypeCode(reqDto.getCooperateContentTypeCode());//SimpleFieldAssign//sourceId:1442881_1
receptionServiceReq.setCooperateContentId(reqDto.getCooperateContentId());//SimpleFieldAssign//sourceId:1442882_1
receptionServiceReq.setSurfaceContName(reqDto.getSurfaceContName());//SimpleFieldAssign//sourceId:1442883_1
receptionServiceReq.setReferenceMessageId(reqDto.getReferenceMessageId());//SimpleFieldAssign//sourceId:1442614_1
receptionServiceReq.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:1494127_1
receptionServiceReq.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:1494128_1
    }

    /*M2获取接收字段[4007]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbInterfaceMode.obtainReceiveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;

QueryIntegerVariableDetailComRespDto retData = new QueryIntegerVariableDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setComNumField(receptionServiceRes_1.getComNumField());//SimpleFieldAssign//sourceId:908038_1
retData.setUseChannelMethod(receptionServiceRes_1.getUseChannelMethod());//SimpleFieldAssign//sourceId:1102394_1
retData.setMessageTemplateCode(receptionServiceRes_1.getMessageTemplateCode());//SimpleFieldAssign//sourceId:1108771_1
retData.setCustomField(receptionServiceRes_1.getCustomField());//SimpleFieldAssign//sourceId:1442623_1
retData.setCustomField1(receptionServiceRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1442636_1
retData.setCustomField2(receptionServiceRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1442637_1
retData.setCustomField3(receptionServiceRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1442655_1
retData.setCustomField4(receptionServiceRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1443716_1
retData.setCustomField5(receptionServiceRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1443717_1
retData.setCustomField6(receptionServiceRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1494134_1
retData.setCustomField7(receptionServiceRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1494135_1
retData.setNewTableTypeCode(receptionServiceRes_1.getNewTableTypeCode());//SimpleFieldAssign//sourceId:1442692_1
retData.setConTableTypeCode(receptionServiceRes_1.getConTableTypeCode());//SimpleFieldAssign//sourceId:1442691_1
    }




return retData;
  }
/**
   * D2获取输出当前标识(公共)[6786]
   * gen by moon at 5/16/2023, 8:56:35 PM
   */
  @Trace(operationName = "D2获取输出当前标识(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainOutPutCurrentCodeComRespDto obtainOutPutCurrentCodeCom(ObtainOutPutCurrentCodeComReqDto reqDto){


      ObtainOutPutCurrentCodeRespDto getCurrentContentCodeRes_1 =null;
//步骤0: M2获取输出当前标识 - obtainOutPutCurrentCode
     //ModelCode: getCurrentContentCode
        ObtainOutPutCurrentCodeRespDto getCurrentContentCodeRes = null;
    ObtainOutPutCurrentCodeReqDto getCurrentContentCodeReq=new ObtainOutPutCurrentCodeReqDto();
  if(reqDto!=null){
      getCurrentContentCodeReq.setComCode1(reqDto.getComCode1());//SimpleFieldAssign//sourceId:948845_1
getCurrentContentCodeReq.setSiblingCodeList(reqDto.getSiblingCodeList());//list-field-assign//sourceId:948846_1
    }

    /*M2获取输出当前标识[6784]  用于新建内容时，获取当前层级内容标识。如新增空间、新增指标。入参上级标识CODE，当前层级所有标识CODE，获取本次新增内容的标识CODE */

      getCurrentContentCodeRes = nbInterfaceMode.obtainOutPutCurrentCode(getCurrentContentCodeReq);


      getCurrentContentCodeRes_1 = getCurrentContentCodeRes;

ObtainOutPutCurrentCodeComRespDto retData = new ObtainOutPutCurrentCodeComRespDto();
  if(getCurrentContentCodeRes_1!=null){
      retData.setComCode(getCurrentContentCodeRes_1.getComCode());//SimpleFieldAssign//sourceId:948850_1
    }




return retData;
  }
/**
   * D2-根据开始时间结束时间计算双周(公共)[6978]
   * gen by moon at 6/24/2023, 10:29:07 PM
   */
  @Trace(operationName = "D2-根据开始时间结束时间计算双周(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCalcDoubleWeekByTimeRangeComRespDto implementCalcDoubleWeekByTimeRangeCom(ImplementCalcDoubleWeekByTimeRangeComReqDto reqDto){


      ImplementCalcDoubleWeekByTimeRangeRespDto calcDoubleWeekByTimeRangeRes_1 =null;
//步骤0: M2-执根据开始结束时间计算双周（特殊方法） - implementCalcDoubleWeekByTimeRange
     //ModelCode: calcDoubleWeekByTimeRange
        ImplementCalcDoubleWeekByTimeRangeRespDto calcDoubleWeekByTimeRangeRes = null;
    ImplementCalcDoubleWeekByTimeRangeReqDto calcDoubleWeekByTimeRangeReq=new ImplementCalcDoubleWeekByTimeRangeReqDto();
  if(reqDto!=null){
      calcDoubleWeekByTimeRangeReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:987968_1
calcDoubleWeekByTimeRangeReq.setCycleIsCutHeadAndTail(reqDto.getCycleIsCutHeadAndTail());//SimpleFieldAssign//sourceId:1058694_1
calcDoubleWeekByTimeRangeReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:987969_1
calcDoubleWeekByTimeRangeReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:987970_1
    }

    /*M2-执根据开始结束时间计算双周（特殊方法）[6977]  入参开始时间A，结束时间B，双周开始第一天，三个时间点，计算AB两个时间点间所有双周周期列表 */
    Assert.isNull(calcDoubleWeekByTimeRangeReq.getComTimeField(),"D2-根据开始时间结束时间计算双周(公共)-M2-执根据开始结束时间计算双周（特殊方法）-通用时间字段不能为空",false);
Assert.isNull(calcDoubleWeekByTimeRangeReq.getCycleStartTime(),"D2-根据开始时间结束时间计算双周(公共)-M2-执根据开始结束时间计算双周（特殊方法）-周期开始时间不能为空",false);
Assert.isNull(calcDoubleWeekByTimeRangeReq.getCycleEndTime(),"D2-根据开始时间结束时间计算双周(公共)-M2-执根据开始结束时间计算双周（特殊方法）-周期结束时间不能为空",false);
      calcDoubleWeekByTimeRangeRes = nbInterfaceMode.implementCalcDoubleWeekByTimeRange(calcDoubleWeekByTimeRangeReq);


      calcDoubleWeekByTimeRangeRes_1 = calcDoubleWeekByTimeRangeRes;

ImplementCalcDoubleWeekByTimeRangeComRespDto retData = new ImplementCalcDoubleWeekByTimeRangeComRespDto();
  if(calcDoubleWeekByTimeRangeRes_1!=null){
      retData.setDoubleWeekList(calcDoubleWeekByTimeRangeRes_1.getDoubleWeekList().stream().map(item -> BeanUtil.toBean(item, DoubleWeekDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:987981_1
    }




return retData;
  }
/**
   * D2执行清洗物理文件(公共)[7200]
   * gen by moon at 6/11/2023, 9:27:21 PM
   */
  @Trace(operationName = "D2执行清洗物理文件(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCleaningPhysicalFilesComRespDto implementCleaningPhysicalFilesCom(ImplementCleaningPhysicalFilesComReqDto reqDto){


      //步骤0: M2执行清洗物理文件(特殊方法) - implementCleaningPhysicalFiles
     //ModelCode: cleaningPhysicalFiles
        ImplementCleaningPhysicalFilesRespDto cleaningPhysicalFilesRes = null;
    ImplementCleaningPhysicalFilesReqDto cleaningPhysicalFilesReq=new ImplementCleaningPhysicalFilesReqDto();
  if(reqDto!=null){
      cleaningPhysicalFilesReq.setCleaningPhysicalFilesList(reqDto.getCleaningPhysicalFilesList());//list-field-assign//sourceId:1035864_1
    }

    /*M2执行清洗物理文件(特殊方法)[7199]   */

      cleaningPhysicalFilesRes = nbInterfaceMode.implementCleaningPhysicalFiles(cleaningPhysicalFilesReq);




ImplementCleaningPhysicalFilesComRespDto retData = new ImplementCleaningPhysicalFilesComRespDto();





return retData;
  }
/**
   * D2执行数据集差集(公共)[7197]
   * gen by moon at 6/12/2023, 11:21:29 AM
   */
  @Trace(operationName = "D2执行数据集差集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCollectionsDiffComRespDto implementCollectionsDiffCom(ImplementCollectionsDiffComReqDto reqDto){


      ImplementCollectionsDiffRespDto getCollectionsDiffRes_1 =null;
//步骤0: M2执行数据集差集 - implementCollectionsDiff
     //ModelCode: getCollectionsDiff
        ImplementCollectionsDiffRespDto getCollectionsDiffRes = null;
    ImplementCollectionsDiffReqDto getCollectionsDiffReq=new ImplementCollectionsDiffReqDto();
  if(reqDto!=null){
      getCollectionsDiffReq.setCollectionsDiffComFatList(reqDto.getCollectionsDiffComFatList());//list-field-assign//sourceId:1035806_1
getCollectionsDiffReq.setCollectionsDiffComSubList(reqDto.getCollectionsDiffComSubList());//list-field-assign//sourceId:1035807_1
    }

    /*M2执行数据集差集[7196]  对比数据集一，数据二，返回数据集一中有，但数据集二中不存在的数据 */

      getCollectionsDiffRes = nbInterfaceMode.implementCollectionsDiff(getCollectionsDiffReq);


      getCollectionsDiffRes_1 = getCollectionsDiffRes;

ImplementCollectionsDiffComRespDto retData = new ImplementCollectionsDiffComRespDto();
  if(getCollectionsDiffRes_1!=null){
      retData.setCollectionsDiffList(getCollectionsDiffRes_1.getCollectionsDiffList());//list-field-assign//sourceId:1035812_1
    }




return retData;
  }
/**
   * D2执行数据集去除空值数据(公共)[7262]
   * gen by moon at 6/27/2023, 1:41:47 PM
   */
  @Trace(operationName = "D2执行数据集去除空值数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataSetRemoveNullDataComRespDto implementDataSetRemoveNullDataCom(ImplementDataSetRemoveNullDataComReqDto reqDto){


      ImplementDataSetRemoveNullDataRespDto dataSetRemoveNullDataRes_1 =null;
//步骤0: M2执行数据集去除空值数据（特殊方法） - implementDataSetRemoveNullData
     //ModelCode: dataSetRemoveNullData
        ImplementDataSetRemoveNullDataRespDto dataSetRemoveNullDataRes = null;
    ImplementDataSetRemoveNullDataReqDto dataSetRemoveNullDataReq=new ImplementDataSetRemoveNullDataReqDto();
  if(reqDto!=null){
      dataSetRemoveNullDataReq.setDataSetRemoveNullDataList(reqDto.getDataSetRemoveNullDataList().stream().map(item -> BeanUtil.toBean(item, DataSetRemoveNullDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1066449_1
    }

    /*M2执行数据集去除空值数据（特殊方法）[7261]  入参数据集，数据集主键A+非主键B,将B字段为空的数据记录过滤掉（不为空的出参） */

      dataSetRemoveNullDataRes = nbInterfaceMode.implementDataSetRemoveNullData(dataSetRemoveNullDataReq);


      dataSetRemoveNullDataRes_1 = dataSetRemoveNullDataRes;

ImplementDataSetRemoveNullDataComRespDto retData = new ImplementDataSetRemoveNullDataComRespDto();
  //todo dong 未找到匹配生成策略,请检查生成策略retData.setDataSetRemoveNullDataList(dataSetRemoveNullDataRes_1.getDataSetRemoveNullDataList().getCommPrimaryKey()/dataSetRemoveNullDataRes_1.getDataSetRemoveNullDataList().getComFloatField()),数据源项; to( ==>tableName:undefined, fieldEnname:dataSetRemoveNullDataList ,uniqueId: 1066451_1 uniqueSourceId:out_null_null) from (varName:undefined fieldundefined)




return retData;
  }
/**
   * D2执行数据集随机一条记录(公共)[7270]
   * gen by moon at 6/28/2023, 1:28:47 AM
   */
  @Trace(operationName = "D2执行数据集随机一条记录(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataStochasticOneComRespDto implementDataStochasticOneCom(ImplementDataStochasticOneComReqDto reqDto){


      ObtainDataStochasticOneRespDto dataStochasticOneRes_1 =null;
//步骤0: M2获取数据集随机一条记录（特殊方法） - obtainDataStochasticOne
     //ModelCode: dataStochasticOne
        ObtainDataStochasticOneRespDto dataStochasticOneRes = null;
    ObtainDataStochasticOneReqDto dataStochasticOneReq=new ObtainDataStochasticOneReqDto();
  if(reqDto!=null){
      dataStochasticOneReq.setDataStochasticOneList(reqDto.getDataStochasticOneList());//list-field-assign//sourceId:1070389_1
    }

    /*M2获取数据集随机一条记录（特殊方法）[7269]  入参数据集，随机出参数据集的单条记录 */

      dataStochasticOneRes = nbInterfaceMode.obtainDataStochasticOne(dataStochasticOneReq);


      dataStochasticOneRes_1 = dataStochasticOneRes;

ImplementDataStochasticOneComRespDto retData = new ImplementDataStochasticOneComRespDto();
  if(dataStochasticOneRes_1!=null){
      retData.setCustomField(dataStochasticOneRes_1.getCustomField());//SimpleFieldAssign//sourceId:1070392_1
    }




return retData;
  }
/**
   * D2查询接收出入参业务字段详情(公共)[7306]
   * gen by moon at 1/21/2024, 9:48:15 PM
   */
  @Trace(operationName = "D2查询接收出入参业务字段详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryAcceptParameterBizFieldDetailComRespDto queryAcceptParameterBizFieldDetailCom(QueryAcceptParameterBizFieldDetailComReqDto reqDto){


      ObtainReceiveFieldsRespDto receptionServiceRes_1 =null;
//步骤0: M2获取接收字段 - obtainReceiveFields
     //ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes = null;
    ObtainReceiveFieldsReqDto receptionServiceReq=new ObtainReceiveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq.setMemberChannelRelationId(reqDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1091537_1
    }

    /*M2获取接收字段[4007]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getMemberChannelRelationId(),"D2查询接收出入参业务字段详情(公共)-M2获取接收字段-成员通道关系ID不能为空",false);
      receptionServiceRes = nbInterfaceMode.obtainReceiveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;

QueryAcceptParameterBizFieldDetailComRespDto retData = new QueryAcceptParameterBizFieldDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setMemberChannelRelationId(receptionServiceRes_1.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1091540_1
    }




return retData;
  }
/**
   * D2执行多字段数据集记录去重(公共)[7323]
   * gen by moon at 8/1/2023, 9:39:15 PM
   */
  @Trace(operationName = "D2执行多字段数据集记录去重(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementManyFieldsDataSetDuplicateRemovalComRespDto implementManyFieldsDataSetDuplicateRemovalCom(ImplementManyFieldsDataSetDuplicateRemovalComReqDto reqDto){


      ImplementManyFieldsDataSetDuplicateRemovalRespDto collectionRemoveDuplicateDataRes_1 =null;
//步骤0: M2执行多字段数据集记录去重（特殊方法） - implementManyFieldsDataSetDuplicateRemoval
     //ModelCode: collectionRemoveDuplicateData
        ImplementManyFieldsDataSetDuplicateRemovalRespDto collectionRemoveDuplicateDataRes = null;
    ImplementManyFieldsDataSetDuplicateRemovalReqDto collectionRemoveDuplicateDataReq=new ImplementManyFieldsDataSetDuplicateRemovalReqDto();
  if(reqDto!= null&&  reqDto.getDataSetDuplicateRemovalList() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetDuplicateRemovalList())){
      collectionRemoveDuplicateDataReq.setDataSetDuplicateRemovalList(reqDto.getDataSetDuplicateRemovalList().stream().map(item -> BeanUtil.toBean(item, DataSetDuplicateRemovalDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1095616_1
    }

    /*M2执行多字段数据集记录去重（特殊方法）[7324]  入参一个数据集，通过去重标识，去除数据集中重复的数据 */

      collectionRemoveDuplicateDataRes = nbInterfaceMode.implementManyFieldsDataSetDuplicateRemoval(collectionRemoveDuplicateDataReq);


      collectionRemoveDuplicateDataRes_1 = collectionRemoveDuplicateDataRes;

ImplementManyFieldsDataSetDuplicateRemovalComRespDto retData = new ImplementManyFieldsDataSetDuplicateRemovalComRespDto();
  if(collectionRemoveDuplicateDataRes_1!=null){
      retData.setDataSetDuplicateRemovalList(collectionRemoveDuplicateDataRes_1.getDataSetDuplicateRemovalList().stream().map(item -> BeanUtil.toBean(item, DataSetDuplicateRemovalDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1095619_1
    }




return retData;
  }
/**
   * D2-执行时间加减固定数值(公共)[7369]
   * gen by moon at 11/29/2023, 3:21:16 AM
   */
  @Trace(operationName = "D2-执行时间加减固定数值(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTimeAddAndSubComRespDto implementTimeAddAndSubCom(ImplementTimeAddAndSubComReqDto reqDto){


      ImplementTimeAddAndSubRespDto timeAddAndSubRes_1 =null;
//步骤0: M2-执行时间加减操作 - implementTimeAddAndSub
     //ModelCode: timeAddAndSub
        ImplementTimeAddAndSubRespDto timeAddAndSubRes = null;
    ImplementTimeAddAndSubReqDto timeAddAndSubReq=new ImplementTimeAddAndSubReqDto();
  if(reqDto!=null){
      timeAddAndSubReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:1111371_1
timeAddAndSubReq.setCalcFormula(reqDto.getCalcFormula());//SimpleFieldAssign//sourceId:1111372_1
timeAddAndSubReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1111370_1
timeAddAndSubReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:1111373_1
    }

    /*M2-执行时间加减操作[7368]   */
    Assert.isNull(timeAddAndSubReq.getComTimeField(),"D2-执行时间加减固定数值(公共)-M2-执行时间加减操作-通用时间字段不能为空",false);
Assert.isNull(timeAddAndSubReq.getCalcFormula(),"D2-执行时间加减固定数值(公共)-M2-执行时间加减操作-通用计算公式不能为空",false);
Assert.isNull(timeAddAndSubReq.getTimeUnitType(),"D2-执行时间加减固定数值(公共)-M2-执行时间加减操作-时间单位类型不能为空",false);
Assert.isNull(timeAddAndSubReq.getComNumField(),"D2-执行时间加减固定数值(公共)-M2-执行时间加减操作-通用数值字段（整数型）不能为空",false);
      timeAddAndSubRes = nbInterfaceMode.implementTimeAddAndSub(timeAddAndSubReq);


      timeAddAndSubRes_1 = timeAddAndSubRes;

ImplementTimeAddAndSubComRespDto retData = new ImplementTimeAddAndSubComRespDto();
  if(timeAddAndSubRes_1!=null){
      retData.setCalcTimeResult(timeAddAndSubRes_1.getCalcTimeResult());//SimpleFieldAssign//sourceId:1111379_1
    }




return retData;
  }
/**
   * D2-执行多时间类型对比(公共)[7376]
   * gen by moon at 9/3/2023, 8:28:58 PM
   */
  @Trace(operationName = "D2-执行多时间类型对比(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementComparisonOfMultipleTimeTypesComRespDto implementComparisonOfMultipleTimeTypesCom(ImplementComparisonOfMultipleTimeTypesComReqDto reqDto){


      ImplementComparisonOfMultipleTimeTypesRespDto comparisonOfMultipleTimeTypesRes_1 =null;
//步骤0: M2-执行多时间类型对比（特殊方法） - implementComparisonOfMultipleTimeTypes
     //ModelCode: comparisonOfMultipleTimeTypes
        ImplementComparisonOfMultipleTimeTypesRespDto comparisonOfMultipleTimeTypesRes = null;
    ImplementComparisonOfMultipleTimeTypesReqDto comparisonOfMultipleTimeTypesReq=new ImplementComparisonOfMultipleTimeTypesReqDto();
  if(reqDto!=null){
      comparisonOfMultipleTimeTypesReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1118319_1
comparisonOfMultipleTimeTypesReq.setCompareTime(reqDto.getCompareTime());//SimpleFieldAssign//sourceId:1118320_1
comparisonOfMultipleTimeTypesReq.setCaluStartTime(reqDto.getCaluStartTime());//SimpleFieldAssign//sourceId:1118321_1
    }

    /*M2-执行多时间类型对比（特殊方法）[7375]  按不同的时间类型（按年比较、按月比较、按天比较、按时间比较），结合入参开始时间（参照值）、结束时间（比较值）两个字段，计算比较值与参照值大小，输出两个时间比较结果之前（小于）、当前（等于）、之后（大于） */
    Assert.isNull(comparisonOfMultipleTimeTypesReq.getTimeUnitType(),"D2-执行多时间类型对比(公共)-M2-执行多时间类型对比（特殊方法）-时间单位类型不能为空",false);
Assert.isNull(comparisonOfMultipleTimeTypesReq.getCompareTime(),"D2-执行多时间类型对比(公共)-M2-执行多时间类型对比（特殊方法）-比较时间不能为空",false);
Assert.isNull(comparisonOfMultipleTimeTypesReq.getCaluStartTime(),"D2-执行多时间类型对比(公共)-M2-执行多时间类型对比（特殊方法）-参照时间不能为空",false);
      comparisonOfMultipleTimeTypesRes = nbInterfaceMode.implementComparisonOfMultipleTimeTypes(comparisonOfMultipleTimeTypesReq);


      comparisonOfMultipleTimeTypesRes_1 = comparisonOfMultipleTimeTypesRes;

ImplementComparisonOfMultipleTimeTypesComRespDto retData = new ImplementComparisonOfMultipleTimeTypesComRespDto();
  if(comparisonOfMultipleTimeTypesRes_1!=null){
      retData.setTimeCompareResult(comparisonOfMultipleTimeTypesRes_1.getTimeCompareResult());//SimpleFieldAssign//sourceId:1118326_1
    }




return retData;
  }
/**
   * D2获取数据集按入参过滤指定记录(公共)[7387]
   * gen by moon at 6/16/2024, 2:26:29 AM
   */
  @Trace(operationName = "D2获取数据集按入参过滤指定记录(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainDataFilterSpecRecByComRespDto obtainDataFilterSpecRecByCom(ObtainDataFilterSpecRecByComReqDto reqDto){


      ObtainDataFilterSpecRecByRespDto dataFilterSpecRecByRes_1 =null;
//步骤0: M2获取数据集按入参过滤指定记录(特殊方法) - obtainDataFilterSpecRecBy
     //ModelCode: dataFilterSpecRecBy
        ObtainDataFilterSpecRecByRespDto dataFilterSpecRecByRes = null;
    ObtainDataFilterSpecRecByReqDto dataFilterSpecRecByReq=new ObtainDataFilterSpecRecByReqDto();
  if(reqDto!= null&&  reqDto.getDataFilterSpecRecByList() !=null&& !CollectionUtil.isEmpty(reqDto.getDataFilterSpecRecByList())){
      dataFilterSpecRecByReq.setDataFilterSpecRecByList(reqDto.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1120316_1
    }
  if(reqDto!=null){
dataFilterSpecRecByReq.setComTxtField(reqDto.getComTxtField());//SimpleFieldAssign//sourceId:1120317_1
    }

    /*M2获取数据集按入参过滤指定记录(特殊方法)[7205]  目前用于购物车步骤判断。入参：步骤数据集+三个步骤字段（字段名与数据集中步骤编码相同）
处理逻辑：入参步骤字段值不为1，则将数据集中步骤编码同名的记录从出参数据集中删除 */
    Assert.isNull(dataFilterSpecRecByReq.getComTxtField(),"D2获取数据集按入参过滤指定记录(公共)-M2获取数据集按入参过滤指定记录(特殊方法)-通用文本字段不能为空",false);
      dataFilterSpecRecByRes = nbInterfaceMode.obtainDataFilterSpecRecBy(dataFilterSpecRecByReq);


      dataFilterSpecRecByRes_1 = dataFilterSpecRecByRes;

ObtainDataFilterSpecRecByComRespDto retData = new ObtainDataFilterSpecRecByComRespDto();
  if(dataFilterSpecRecByRes_1!=null){
      retData.setDataFilterSpecRecByList(dataFilterSpecRecByRes_1.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1120321_1
    }




return retData;
  }
/**
   * D2-执行富文本转markdown(公共)[7390]
   * gen by moon at 9/14/2023, 4:14:01 PM
   */
  @Trace(operationName = "D2-执行富文本转markdown(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementHypertextTurnToMarkdownComRespDto implementHypertextTurnToMarkdownCom(ImplementHypertextTurnToMarkdownComReqDto reqDto){


      ImplementHypertextTurnToMarkdownRespDto hypertextTurnToMarkdownRes_1 =null;
//步骤0: M2-执行富文本转markdown（特殊方法） - implementHypertextTurnToMarkdown
     //ModelCode: hypertextTurnToMarkdown
        ImplementHypertextTurnToMarkdownRespDto hypertextTurnToMarkdownRes = null;
    ImplementHypertextTurnToMarkdownReqDto hypertextTurnToMarkdownReq=new ImplementHypertextTurnToMarkdownReqDto();
  if(reqDto!=null){
      hypertextTurnToMarkdownReq.setHypertextContent(reqDto.getHypertextContent());//SimpleFieldAssign//sourceId:1120446_1
    }

    /*M2-执行富文本转markdown（特殊方法）[7389]   */
    Assert.isNull(hypertextTurnToMarkdownReq.getHypertextContent(),"D2-执行富文本转markdown(公共)-M2-执行富文本转markdown（特殊方法）-超文本内容不能为空",false);
      hypertextTurnToMarkdownRes = nbInterfaceMode.implementHypertextTurnToMarkdown(hypertextTurnToMarkdownReq);


      hypertextTurnToMarkdownRes_1 = hypertextTurnToMarkdownRes;

ImplementHypertextTurnToMarkdownComRespDto retData = new ImplementHypertextTurnToMarkdownComRespDto();
  if(hypertextTurnToMarkdownRes_1!=null){
      retData.setMarkdownContent(hypertextTurnToMarkdownRes_1.getMarkdownContent());//SimpleFieldAssign//sourceId:1120449_1
    }




return retData;
  }
/**
   * D2执行对接第三方发送消息(公共)[7421]
   * gen by moon at 9/25/2023, 10:44:49 AM
   */
  @Trace(operationName = "D2执行对接第三方发送消息(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementObtainThirdSendMsgComRespDto implementObtainThirdSendMsgCom(ImplementObtainThirdSendMsgComReqDto reqDto){


      //步骤0: M2-执行对接第三方发送消息（特殊方法） - implementObtainThirdSendMsg
     //ModelCode: obtainThirdSendMsg
        ImplementObtainThirdSendMsgRespDto obtainThirdSendMsgRes = null;
    ImplementObtainThirdSendMsgReqDto obtainThirdSendMsgReq=new ImplementObtainThirdSendMsgReqDto();
  if(reqDto!=null){
      obtainThirdSendMsgReq.setMessageServeUrl(reqDto.getMessageServeUrl());//SimpleFieldAssign//sourceId:1135340_1
obtainThirdSendMsgReq.setMsgAppIdFields(reqDto.getMsgAppIdFields());//SimpleFieldAssign//sourceId:1123561_1
obtainThirdSendMsgReq.setInterfaceMethod(reqDto.getInterfaceMethod());//SimpleFieldAssign//sourceId:1123573_1
obtainThirdSendMsgReq.setMessageTitleFields(reqDto.getMessageTitleFields());//SimpleFieldAssign//sourceId:1123555_1
obtainThirdSendMsgReq.setMessageContentFields(reqDto.getMessageContentFields());//SimpleFieldAssign//sourceId:1123556_1
obtainThirdSendMsgReq.setMessageReceiverFields(reqDto.getMessageReceiverFields());//SimpleFieldAssign//sourceId:1123557_1
obtainThirdSendMsgReq.setMsgAppId(reqDto.getMsgAppId());//SimpleFieldAssign//sourceId:1123562_1
obtainThirdSendMsgReq.setMessageTitle(reqDto.getMessageTitle());//SimpleFieldAssign//sourceId:1123558_1
obtainThirdSendMsgReq.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1123559_1
obtainThirdSendMsgReq.setMessageReceiver(reqDto.getMessageReceiver());//SimpleFieldAssign//sourceId:1123560_1
    }

    /*M2-执行对接第三方发送消息（特殊方法）[7395]   */
    Assert.isNull(obtainThirdSendMsgReq.getMessageServeUrl(),"D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息服务地址不能为空",false);
Assert.isNull(obtainThirdSendMsgReq.getMsgAppIdFields(),"D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息应用ID字段名不能为空",false);
Assert.isNull(obtainThirdSendMsgReq.getInterfaceMethod(),"D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-接口请求类型不能为空",false);
Assert.isNull(obtainThirdSendMsgReq.getMessageTitleFields(),"D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息标题字段名不能为空",false);
Assert.isNull(obtainThirdSendMsgReq.getMessageContentFields(),"D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息内容字段名不能为空",false);
Assert.isNull(obtainThirdSendMsgReq.getMessageReceiverFields(),"D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息接收方字段名不能为空",false);
Assert.isNull(obtainThirdSendMsgReq.getMsgAppId(),"D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息应用ID不能为空",false);
Assert.isNull(obtainThirdSendMsgReq.getMessageReceiver(),"D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息接收方不能为空",false);
      obtainThirdSendMsgRes = nbInterfaceMode.implementObtainThirdSendMsg(obtainThirdSendMsgReq);




ImplementObtainThirdSendMsgComRespDto retData = new ImplementObtainThirdSendMsgComRespDto();





return retData;
  }
/**
   * D2-获取字符串长度(公共)[7491]
   * gen by moon at 10/4/2023, 10:16:38 PM
   */
  @Trace(operationName = "D2-获取字符串长度(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementGetStringLengthComRespDto implementGetStringLengthCom(ImplementGetStringLengthComReqDto reqDto){


      ImplementGetStringLengthRespDto stringLengthRes_1 =null;
//步骤0: M2-获取字符串长度（特殊方法） - implementGetStringLength
     //ModelCode: stringLength
        ImplementGetStringLengthRespDto stringLengthRes = null;
    ImplementGetStringLengthReqDto stringLengthReq=new ImplementGetStringLengthReqDto();
  if(reqDto!=null){
      stringLengthReq.setCustomText(reqDto.getCustomText());//SimpleFieldAssign//sourceId:1159234_1
    }

    /*M2-获取字符串长度（特殊方法）[7490]   */
    Assert.isNull(stringLengthReq.getCustomText(),"D2-获取字符串长度(公共)-M2-获取字符串长度（特殊方法）-自定义文本字段不能为空",false);
      stringLengthRes = nbInterfaceMode.implementGetStringLength(stringLengthReq);


      stringLengthRes_1 = stringLengthRes;

ImplementGetStringLengthComRespDto retData = new ImplementGetStringLengthComRespDto();
  if(stringLengthRes_1!=null){
      retData.setOutputNum(stringLengthRes_1.getOutputNum());//SimpleFieldAssign//sourceId:1159238_1
    }




return retData;
  }
/**
   * D2-执行数据集根据排序字段取最大最小(公共)[7500]
   * gen by moon at 10/5/2023, 3:54:43 PM
   */
  @Trace(operationName = "D2-执行数据集根据排序字段取最大最小(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataListGetMaxOrMiniByOrderNumberComRespDto implementDataListGetMaxOrMiniByOrderNumberCom(ImplementDataListGetMaxOrMiniByOrderNumberComReqDto reqDto){


      ImplementDataListGetMaxOrMiniByOrderNumberRespDto dataListGetMaxOrMiniByOrderNumberRes_1 =null;
//步骤0: M2-执行数据集根据排序字段取最大最小（特殊方法） - implementDataListGetMaxOrMiniByOrderNumber
     //ModelCode: dataListGetMaxOrMiniByOrderNumber
        ImplementDataListGetMaxOrMiniByOrderNumberRespDto dataListGetMaxOrMiniByOrderNumberRes = null;
    ImplementDataListGetMaxOrMiniByOrderNumberReqDto dataListGetMaxOrMiniByOrderNumberReq=new ImplementDataListGetMaxOrMiniByOrderNumberReqDto();
  if(reqDto!=null){
      dataListGetMaxOrMiniByOrderNumberReq.setOrderSizeType(reqDto.getOrderSizeType());//SimpleFieldAssign//sourceId:1162306_1
dataListGetMaxOrMiniByOrderNumberReq.setComDatasList(reqDto.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1162307_1
    }

    /*M2-执行数据集根据排序字段取最大最小（特殊方法）[7499]   */

      dataListGetMaxOrMiniByOrderNumberRes = nbInterfaceMode.implementDataListGetMaxOrMiniByOrderNumber(dataListGetMaxOrMiniByOrderNumberReq);


      dataListGetMaxOrMiniByOrderNumberRes_1 = dataListGetMaxOrMiniByOrderNumberRes;

ImplementDataListGetMaxOrMiniByOrderNumberComRespDto retData = new ImplementDataListGetMaxOrMiniByOrderNumberComRespDto();
  if(dataListGetMaxOrMiniByOrderNumberRes_1!=null){
      retData.setCustomField(dataListGetMaxOrMiniByOrderNumberRes_1.getCustomField());//SimpleFieldAssign//sourceId:1162311_1
retData.setCustomField1(dataListGetMaxOrMiniByOrderNumberRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1162336_1
    }




return retData;
  }
/**
   * D2-执行两数相比输出指定文本(公共)[7513]
   * gen by moon at 12/2/2023, 12:08:53 AM
   */
  @Trace(operationName = "D2-执行两数相比输出指定文本(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCompTwoNumberOutputSpecTextComRespDto implementCompTwoNumberOutputSpecTextCom(ImplementCompTwoNumberOutputSpecTextComReqDto reqDto){


      ImplementCompTwoNumberOutputSpecTextRespDto compTwoNumberOutputSpecTextRes_1 =null;
//步骤0: M2-执行两数相比输出指定文本（特殊方法） - implementCompTwoNumberOutputSpecText
     //ModelCode: compTwoNumberOutputSpecText
        ImplementCompTwoNumberOutputSpecTextRespDto compTwoNumberOutputSpecTextRes = null;
    ImplementCompTwoNumberOutputSpecTextReqDto compTwoNumberOutputSpecTextReq=new ImplementCompTwoNumberOutputSpecTextReqDto();
  if(reqDto!=null){
      compTwoNumberOutputSpecTextReq.setComFloatField(reqDto.getComFloatField());//SimpleFieldAssign//sourceId:1362248_1
compTwoNumberOutputSpecTextReq.setFixedValue(reqDto.getFixedValue());//SimpleFieldAssign//sourceId:1168241_1
compTwoNumberOutputSpecTextReq.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:1363795_1
    }

    /*M2-执行两数相比输出指定文本（特殊方法）[7512]  入参：A（数值），B（约定固定数值）
出参：C（文本）
业务描述：
目的是为了实现在显示任务超时时长时，如果超时时长小于100小时（系统配置），则显示超时时长；如果超时时长大于100小时，则显示100+，业务场景中显示文案为”当前汇报任务已逾期100+小时，请及时汇报“
逻辑描述：
两个数值A（10），B（100），如果A小于B，则输出A（10）
如果A大于B，则输出B（100+）
注意：输出的B是在入参100的基础上拼接了”+“符号 */
    Assert.isNull(compTwoNumberOutputSpecTextReq.getComFloatField(),"D2-执行两数相比输出指定文本(公共)-M2-执行两数相比输出指定文本（特殊方法）-通用数值字段（小数型）不能为空",false);
Assert.isNull(compTwoNumberOutputSpecTextReq.getFixedValue(),"D2-执行两数相比输出指定文本(公共)-M2-执行两数相比输出指定文本（特殊方法）-固定数值不能为空",false);
      compTwoNumberOutputSpecTextRes = nbInterfaceMode.implementCompTwoNumberOutputSpecText(compTwoNumberOutputSpecTextReq);


      compTwoNumberOutputSpecTextRes_1 = compTwoNumberOutputSpecTextRes;

ImplementCompTwoNumberOutputSpecTextComRespDto retData = new ImplementCompTwoNumberOutputSpecTextComRespDto();
  if(compTwoNumberOutputSpecTextRes_1!=null){
      retData.setCustomField(compTwoNumberOutputSpecTextRes_1.getCustomField());//SimpleFieldAssign//sourceId:1168307_1
    }




return retData;
  }
/**
   * D2执行数据集按指定格式转文本(公共)[7515]
   * gen by moon at 12/12/2023, 7:18:54 PM
   */
  @Trace(operationName = "D2执行数据集按指定格式转文本(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataAppointFormatShiftTextComRespDto implementDataAppointFormatShiftTextCom(ImplementDataAppointFormatShiftTextComReqDto reqDto){


      ImplementDataAppointFormatShiftTextRespDto dataAppointFormatShiftTextRes_1 =null;
//步骤0: M2执行数据集按指定格式转文本 - implementDataAppointFormatShiftText
     //ModelCode: dataAppointFormatShiftText
        ImplementDataAppointFormatShiftTextRespDto dataAppointFormatShiftTextRes = null;
    ImplementDataAppointFormatShiftTextReqDto dataAppointFormatShiftTextReq=new ImplementDataAppointFormatShiftTextReqDto();
  if(reqDto!=null){
      dataAppointFormatShiftTextReq.setDataAppointFormatShiftTextList(reqDto.getDataAppointFormatShiftTextList());//list-field-assign//sourceId:1168447_1
dataAppointFormatShiftTextReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1168448_1
    }

    /*M2执行数据集按指定格式转文本[7419]   */

      dataAppointFormatShiftTextRes = nbInterfaceMode.implementDataAppointFormatShiftText(dataAppointFormatShiftTextReq);


      dataAppointFormatShiftTextRes_1 = dataAppointFormatShiftTextRes;

ImplementDataAppointFormatShiftTextComRespDto retData = new ImplementDataAppointFormatShiftTextComRespDto();
  if(dataAppointFormatShiftTextRes_1!=null){
      retData.setCustomText(dataAppointFormatShiftTextRes_1.getCustomText());//SimpleFieldAssign//sourceId:1168457_1
    }




return retData;
  }
/**
   * D2-执行markdown转文本(公共)[7517]
   * gen by moon at 10/9/2023, 8:42:56 PM
   */
  @Trace(operationName = "D2-执行markdown转文本(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementMarkdownTurnToTextComRespDto implementMarkdownTurnToTextCom(ImplementMarkdownTurnToTextComReqDto reqDto){


      ImplementMarkdownTurnToTextRespDto markdownTurnToTextRes_1 =null;
//步骤0: M2-执行markdown转文本（特殊方法） - implementMarkdownTurnToText
     //ModelCode: markdownTurnToText
        ImplementMarkdownTurnToTextRespDto markdownTurnToTextRes = null;
    ImplementMarkdownTurnToTextReqDto markdownTurnToTextReq=new ImplementMarkdownTurnToTextReqDto();
  if(reqDto!=null){
      markdownTurnToTextReq.setMarkdownContent(reqDto.getMarkdownContent());//SimpleFieldAssign//sourceId:1168553_1
    }

    /*M2-执行markdown转文本（特殊方法）[7516]   */

      markdownTurnToTextRes = nbInterfaceMode.implementMarkdownTurnToText(markdownTurnToTextReq);


      markdownTurnToTextRes_1 = markdownTurnToTextRes;

ImplementMarkdownTurnToTextComRespDto retData = new ImplementMarkdownTurnToTextComRespDto();
  if(markdownTurnToTextRes_1!=null){
      retData.setCustomText(markdownTurnToTextRes_1.getCustomText());//SimpleFieldAssign//sourceId:1168556_1
    }




return retData;
  }
/**
   * D2-执行markdown数据集转文本(公共)[7597]
   * gen by moon at 10/22/2023, 7:36:16 PM
   */
  @Trace(operationName = "D2-执行markdown数据集转文本(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementMarkdownDataListTurnToTextComRespDto implementMarkdownDataListTurnToTextCom(ImplementMarkdownDataListTurnToTextComReqDto reqDto){


      ImplementMarkdownDataListTurnToTextRespDto markdownDataListTurnToTextRes_1 =null;
//步骤0: M2-执行markdown数据集转文本 - implementMarkdownDataListTurnToText
     //ModelCode: markdownDataListTurnToText
        ImplementMarkdownDataListTurnToTextRespDto markdownDataListTurnToTextRes = null;
    ImplementMarkdownDataListTurnToTextReqDto markdownDataListTurnToTextReq=new ImplementMarkdownDataListTurnToTextReqDto();
  if(reqDto!=null){
      markdownDataListTurnToTextReq.setMarkdownDataListTurnToTextList(reqDto.getMarkdownDataListTurnToTextList().stream().map(item -> BeanUtil.toBean(item, MarkdownDataListTurnToTextDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1199573_1
    }

    /*M2-执行markdown数据集转文本[7596]   */

      markdownDataListTurnToTextRes = nbInterfaceMode.implementMarkdownDataListTurnToText(markdownDataListTurnToTextReq);


      markdownDataListTurnToTextRes_1 = markdownDataListTurnToTextRes;

ImplementMarkdownDataListTurnToTextComRespDto retData = new ImplementMarkdownDataListTurnToTextComRespDto();
  if(markdownDataListTurnToTextRes_1!=null){
      retData.setMarkdownDataListTurnToTextList(markdownDataListTurnToTextRes_1.getMarkdownDataListTurnToTextList().stream().map(item -> BeanUtil.toBean(item, MarkdownDataListTurnToTextDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1199576_1
    }




return retData;
  }
/**
   * D2-执行加密解密(公共)[7615]
   * gen by moon at 10/26/2023, 11:02:37 PM
   */
  @Trace(operationName = "D2-执行加密解密(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementEncryptionAndDecryptionComRespDto implementEncryptionAndDecryptionCom(ImplementEncryptionAndDecryptionComReqDto reqDto){


      ImplementEncryptionAndDecryptionRespDto encryptionAndDecryptionRes_1 =null;
//步骤0: M2-执行加密解密（特殊方法） - implementEncryptionAndDecryption
     //ModelCode: encryptionAndDecryption
        ImplementEncryptionAndDecryptionRespDto encryptionAndDecryptionRes = null;
    ImplementEncryptionAndDecryptionReqDto encryptionAndDecryptionReq=new ImplementEncryptionAndDecryptionReqDto();
  if(reqDto!=null){
      encryptionAndDecryptionReq.setEncryptionOrDecryption(reqDto.getEncryptionOrDecryption());//SimpleFieldAssign//sourceId:1210191_1
encryptionAndDecryptionReq.setEncryptionAndDecryptionMode(reqDto.getEncryptionAndDecryptionMode());//SimpleFieldAssign//sourceId:1210192_1
encryptionAndDecryptionReq.setEncryptionAndDecryptionContent(reqDto.getEncryptionAndDecryptionContent());//SimpleFieldAssign//sourceId:1210193_1
    }

    /*M2-执行加密解密（特殊方法）[7614]   */
    Assert.isNull(encryptionAndDecryptionReq.getEncryptionOrDecryption(),"D2-执行加密解密(公共)-M2-执行加密解密（特殊方法）-加密解密类型不能为空",false);
Assert.isNull(encryptionAndDecryptionReq.getEncryptionAndDecryptionMode(),"D2-执行加密解密(公共)-M2-执行加密解密（特殊方法）-加密解密方式不能为空",false);
Assert.isNull(encryptionAndDecryptionReq.getEncryptionAndDecryptionContent(),"D2-执行加密解密(公共)-M2-执行加密解密（特殊方法）-加密解密文本不能为空",false);
      encryptionAndDecryptionRes = nbInterfaceMode.implementEncryptionAndDecryption(encryptionAndDecryptionReq);


      encryptionAndDecryptionRes_1 = encryptionAndDecryptionRes;

ImplementEncryptionAndDecryptionComRespDto retData = new ImplementEncryptionAndDecryptionComRespDto();
  if(encryptionAndDecryptionRes_1!=null){
      retData.setEncryptionAndDecryptionModeResult(encryptionAndDecryptionRes_1.getEncryptionAndDecryptionModeResult());//SimpleFieldAssign//sourceId:1210198_1
    }




return retData;
  }
/**
   * D2-执行固定密钥加密解密(公共)[7615]
   * gen by moon at 11/1/2023, 6:09:18 PM
   */
  @Trace(operationName = "D2-执行固定密钥加密解密(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementEncryptionAndDecryptionByFixedKeyComRespDto implementEncryptionAndDecryptionByFixedKeyCom(ImplementEncryptionAndDecryptionByFixedKeyComReqDto reqDto){


      ImplementEncryptionAndDecryptionByFixedKeyRespDto encryptionAndDecryptionByFixedKeyRes_1 =null;
//步骤0: M2-执行固定密钥加密解密（特殊方法） - implementEncryptionAndDecryptionByFixedKey
     //ModelCode: encryptionAndDecryptionByFixedKey
        ImplementEncryptionAndDecryptionByFixedKeyRespDto encryptionAndDecryptionByFixedKeyRes = null;
    ImplementEncryptionAndDecryptionByFixedKeyReqDto encryptionAndDecryptionByFixedKeyReq=new ImplementEncryptionAndDecryptionByFixedKeyReqDto();
  if(reqDto!=null){
      encryptionAndDecryptionByFixedKeyReq.setEncryptionOrDecryption(reqDto.getEncryptionOrDecryption());//SimpleFieldAssign//sourceId:1210191_1
encryptionAndDecryptionByFixedKeyReq.setEncryptionAndDecryptionMode(reqDto.getEncryptionAndDecryptionMode());//SimpleFieldAssign//sourceId:1210192_1
encryptionAndDecryptionByFixedKeyReq.setEncryptionAndDecryptionContent(reqDto.getEncryptionAndDecryptionContent());//SimpleFieldAssign//sourceId:1210193_1
    }

    /*M2-执行固定密钥加密解密（特殊方法）[7614]   */
    Assert.isNull(encryptionAndDecryptionByFixedKeyReq.getEncryptionOrDecryption(),"D2-执行固定密钥加密解密(公共)-M2-执行固定密钥加密解密（特殊方法）-加密解密类型不能为空",false);
Assert.isNull(encryptionAndDecryptionByFixedKeyReq.getEncryptionAndDecryptionMode(),"D2-执行固定密钥加密解密(公共)-M2-执行固定密钥加密解密（特殊方法）-加密解密方式不能为空",false);
Assert.isNull(encryptionAndDecryptionByFixedKeyReq.getEncryptionAndDecryptionContent(),"D2-执行固定密钥加密解密(公共)-M2-执行固定密钥加密解密（特殊方法）-加密解密文本不能为空",false);
      encryptionAndDecryptionByFixedKeyRes = nbInterfaceMode.implementEncryptionAndDecryptionByFixedKey(encryptionAndDecryptionByFixedKeyReq);


      encryptionAndDecryptionByFixedKeyRes_1 = encryptionAndDecryptionByFixedKeyRes;

ImplementEncryptionAndDecryptionByFixedKeyComRespDto retData = new ImplementEncryptionAndDecryptionByFixedKeyComRespDto();
  if(encryptionAndDecryptionByFixedKeyRes_1!=null){
      retData.setEncryptionAndDecryptionModeResult(encryptionAndDecryptionByFixedKeyRes_1.getEncryptionAndDecryptionModeResult());//SimpleFieldAssign//sourceId:1210198_1
    }




return retData;
  }
/**
   * D2-执行动态密钥加密解密(公共)[7619]
   * gen by moon at 10/28/2023, 1:22:40 AM
   */
  @Trace(operationName = "D2-执行动态密钥加密解密(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementEncryptionAndDecryptionByDynamicKeyComRespDto implementEncryptionAndDecryptionByDynamicKeyCom(ImplementEncryptionAndDecryptionByDynamicKeyComReqDto reqDto){


      ImplementEncryptionAndDecryptionByDynamicKeyRespDto encryptionAndDecryptionByDynamicKeyRes_1 =null;
//步骤0: M2-执行动态密钥加密解密（特殊方法） - implementEncryptionAndDecryptionByDynamicKey
     //ModelCode: encryptionAndDecryptionByDynamicKey
        ImplementEncryptionAndDecryptionByDynamicKeyRespDto encryptionAndDecryptionByDynamicKeyRes = null;
    ImplementEncryptionAndDecryptionByDynamicKeyReqDto encryptionAndDecryptionByDynamicKeyReq=new ImplementEncryptionAndDecryptionByDynamicKeyReqDto();
  if(reqDto!=null){
      encryptionAndDecryptionByDynamicKeyReq.setEncryptionOrDecryption(reqDto.getEncryptionOrDecryption());//SimpleFieldAssign//sourceId:1212264_1
encryptionAndDecryptionByDynamicKeyReq.setEncryptionAndDecryptionMode(reqDto.getEncryptionAndDecryptionMode());//SimpleFieldAssign//sourceId:1212265_1
      encryptionAndDecryptionByDynamicKeyReq.setSecretKey(reqDto.getSecretKey());//SimpleFieldAssign//sourceId:1212266_
      encryptionAndDecryptionByDynamicKeyReq.setInitVector(reqDto.getInitVector());//SimpleFieldAssign//sourceId:1212401_1
encryptionAndDecryptionByDynamicKeyReq.setEncryptionAndDecryptionContent(reqDto.getEncryptionAndDecryptionContent());//SimpleFieldAssign//sourceId:1212267_1
    }

    /*M2-执行动态密钥加密解密（特殊方法）[7618]   */
    Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getEncryptionOrDecryption(),"D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-加密解密类型不能为空",false);
Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getEncryptionAndDecryptionMode(),"D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-加密解密方式不能为空",false);
Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getSecretKey(),"D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-动态密钥不能为空",false);
Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getInitVector(),"D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-初始化向量不能为空",false);
Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getEncryptionAndDecryptionContent(),"D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-加密解密文本不能为空",false);
      encryptionAndDecryptionByDynamicKeyRes = nbInterfaceMode.implementEncryptionAndDecryptionByDynamicKey(encryptionAndDecryptionByDynamicKeyReq);


      encryptionAndDecryptionByDynamicKeyRes_1 = encryptionAndDecryptionByDynamicKeyRes;

ImplementEncryptionAndDecryptionByDynamicKeyComRespDto retData = new ImplementEncryptionAndDecryptionByDynamicKeyComRespDto();
  if(encryptionAndDecryptionByDynamicKeyRes_1!=null){
      retData.setEncryptionAndDecryptionModeResult(encryptionAndDecryptionByDynamicKeyRes_1.getEncryptionAndDecryptionModeResult());//SimpleFieldAssign//sourceId:1212273_1
    }




return retData;
  }

/**
   * D2-执行两时间之间加减(公共)[8036]
   * gen by moon at 11/29/2023, 4:54:40 PM
   */
  @Trace(operationName = "D2-执行两时间之间加减(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTwoTimeAddAndSubComRespDto implementTwoTimeAddAndSubCom(ImplementTwoTimeAddAndSubComReqDto reqDto){


      ImplementTwoTimeAddAndSubRespDto twoTimeAddAndSubRes_1 =null;
      //步骤0: M2-执行两时间加减（特殊方法） - implementTwoTimeAddAndSub
     //ModelCode: twoTimeAddAndSub
        ImplementTwoTimeAddAndSubRespDto twoTimeAddAndSubRes = null;
    ImplementTwoTimeAddAndSubReqDto twoTimeAddAndSubReq=new ImplementTwoTimeAddAndSubReqDto();
  if(reqDto!=null){
      twoTimeAddAndSubReq.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1360031_1
twoTimeAddAndSubReq.setCalcEndTime(reqDto.getCalcEndTime());//SimpleFieldAssign//sourceId:1360032_1
twoTimeAddAndSubReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1360033_1
twoTimeAddAndSubReq.setCalcFormula(reqDto.getCalcFormula());//SimpleFieldAssign//sourceId:1360034_1
twoTimeAddAndSubReq.setDeviationDurationCompRule(reqDto.getDeviationDurationCompRule());//SimpleFieldAssign//sourceId:1360054_1
      twoTimeAddAndSubReq.setDecimalPointRules(reqDto.getDecimalPointRules());
      twoTimeAddAndSubReq.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());
    }

    /*M2-执行两时间加减（特殊方法）[8035]  入参：计算开始时间，计算结束时间，时间单位（月、天、时、分、秒。。），计算类型（加或减）。 用计算开始时间加或减计算结束时间，计算输入结果时间，计算出两个时间点之前的时间单位（如xx天，xx小时，xx分钟） */

      twoTimeAddAndSubRes = nbInterfaceMode.implementTwoTimeAddAndSub(twoTimeAddAndSubReq);


      twoTimeAddAndSubRes_1 = twoTimeAddAndSubRes;

ImplementTwoTimeAddAndSubComRespDto retData = new ImplementTwoTimeAddAndSubComRespDto();
  if(twoTimeAddAndSubRes_1!=null){
      retData.setTimeCalcResult(twoTimeAddAndSubRes_1.getTimeCalcResult());//SimpleFieldAssign//sourceId:1360058_1
    }




return retData;
  }
/**
   * D2-计算两个数值相加(公共)[8137]
   * gen by moon at 12/12/2023, 5:00:36 AM
   */
  @Trace(operationName = "D2-计算两个数值相加(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsCom(CalculateAdditionOfTwoNumsComReqDto reqDto){


      CalculateAdditionOfTwoNumsRespDto additionOfTwoNumRes_1 =null;
//步骤0: M2计算两个数值相加（特殊方法） - calculateAdditionOfTwoNums
     //ModelCode: additionOfTwoNum
        CalculateAdditionOfTwoNumsRespDto additionOfTwoNumRes = null;
    CalculateAdditionOfTwoNumsReqDto additionOfTwoNumReq=new CalculateAdditionOfTwoNumsReqDto();
  if(reqDto!=null){
      additionOfTwoNumReq.setCalcPara1(reqDto.getCalcPara1());//SimpleFieldAssign//sourceId:1410384_1
additionOfTwoNumReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:1410385_1
    }

    /*M2计算两个数值相加（特殊方法）[6472]  用户指标数据计算，入参两个数值，计算两数之和 */
    Assert.isNull(additionOfTwoNumReq.getCalcPara1(),"D2-计算两个数值相加(公共)-M2计算两个数值相加（特殊方法）-计算入参1不能为空",false);
Assert.isNull(additionOfTwoNumReq.getCalcPara2(),"D2-计算两个数值相加(公共)-M2计算两个数值相加（特殊方法）-计算入参2不能为空",false);
      additionOfTwoNumRes = nbInterfaceMode.calculateAdditionOfTwoNums(additionOfTwoNumReq);


      additionOfTwoNumRes_1 = additionOfTwoNumRes;

CalculateAdditionOfTwoNumsComRespDto retData = new CalculateAdditionOfTwoNumsComRespDto();
  if(additionOfTwoNumRes_1!=null){
      retData.setCalcResult(additionOfTwoNumRes_1.getCalcResult());//SimpleFieldAssign//sourceId:1410389_1
    }




return retData;
  }
/**
   * D2判断数据集按入参去N条(公共)[8146]
   * gen by moon at 12/14/2023, 2:50:57 PM
   */
  @Trace(operationName = "D2判断数据集按入参去N条(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeDataPressRemoveMultipleEntriesComRespDto judgeDataPressRemoveMultipleEntriesCom(JudgeDataPressRemoveMultipleEntriesComReqDto reqDto){


      JudgeDataPressRemoveMultipleEntriesRespDto dataPressRemoveMultipleEntriesRes_1 =null;
//步骤0: M2判断数据集按入参去N条 - judgeDataPressRemoveMultipleEntries
     //ModelCode: dataPressRemoveMultipleEntries
        JudgeDataPressRemoveMultipleEntriesRespDto dataPressRemoveMultipleEntriesRes = null;
    JudgeDataPressRemoveMultipleEntriesReqDto dataPressRemoveMultipleEntriesReq=new JudgeDataPressRemoveMultipleEntriesReqDto();
  if(reqDto!=null){
      dataPressRemoveMultipleEntriesReq.setDataFilterSpecRecByList(reqDto.getDataPressRemoveMultipleEntriesList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1414819_1
dataPressRemoveMultipleEntriesReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1414822_1
    }

    /*M2判断数据集按入参去N条[8147]   */
    Assert.isNull(dataPressRemoveMultipleEntriesReq.getCustomField(),"D2判断数据集按入参去N条(公共)-M2判断数据集按入参去N条-自定义字段不能为空",false);
      dataPressRemoveMultipleEntriesRes = nbInterfaceMode.judgeDataPressRemoveMultipleEntries(dataPressRemoveMultipleEntriesReq);


      dataPressRemoveMultipleEntriesRes_1 = dataPressRemoveMultipleEntriesRes;

JudgeDataPressRemoveMultipleEntriesComRespDto retData = new JudgeDataPressRemoveMultipleEntriesComRespDto();
  if(dataPressRemoveMultipleEntriesRes_1!=null){
      retData.setDataPressRemoveMultipleEntriesList(dataPressRemoveMultipleEntriesRes_1.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataPressRemoveMultipleEntriesDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1414826_1
    }




return retData;
  }
/**
   * D2执行接文本字段数据集(公共)[8148]
   * gen by moon at 12/16/2023, 11:14:47 PM
   */
  @Trace(operationName = "D2执行接文本字段数据集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementConnectTextFieldDatasetComRespDto implementConnectTextFieldDatasetCom(ImplementConnectTextFieldDatasetComReqDto reqDto){


      ImplementConnectTextFieldDatasetRespDto receptionServiceRes_1 =null;
//步骤0: M2执行接文本字段数据集 - implementConnectTextFieldDataset
     //ModelCode: receptionService
        ImplementConnectTextFieldDatasetRespDto receptionServiceRes = null;
    ImplementConnectTextFieldDatasetReqDto receptionServiceReq=new ImplementConnectTextFieldDatasetReqDto();
  if(reqDto!= null&&  reqDto.getConnectTextFieldDatasetList() !=null&& !CollectionUtil.isEmpty(reqDto.getConnectTextFieldDatasetList())){
      receptionServiceReq.setConnectTextFieldDatasetList(reqDto.getConnectTextFieldDatasetList().stream().map(item -> BeanUtil.toBean(item, ConnectTextFieldDatasetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1414833_1
    }

    /*M2执行接文本字段数据集[8149]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbInterfaceMode.implementConnectTextFieldDataset(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;

ImplementConnectTextFieldDatasetComRespDto retData = new ImplementConnectTextFieldDatasetComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setConnectTextFieldDatasetList(receptionServiceRes_1.getConnectTextFieldDatasetList().stream().map(item -> BeanUtil.toBean(item, ConnectTextFieldDatasetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1414845_1
    }




return retData;
  }
/**
   * D2执行字段名与值转数据集(公共)[8173]
   * gen by moon at 12/21/2023, 12:35:06 AM
   */
  @Trace(operationName = "D2执行字段名与值转数据集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFieldsNameAndValueToOneDatasComRespDto implementFieldsNameAndValueToOneDatasCom(ImplementFieldsNameAndValueToOneDatasComReqDto reqDto){


      ImplementFieldsNameAndValueToOneDatasRespDto fieldsNameAndValueToOneDatasRes_1 =null;
//步骤0: M2执行字段名与值转数据集 - implementFieldsNameAndValueToOneDatas
     //ModelCode: fieldsNameAndValueToOneDatas
        ImplementFieldsNameAndValueToOneDatasRespDto fieldsNameAndValueToOneDatasRes = null;
    ImplementFieldsNameAndValueToOneDatasReqDto fieldsNameAndValueToOneDatasReq=new ImplementFieldsNameAndValueToOneDatasReqDto();
  if(reqDto!=null){
      fieldsNameAndValueToOneDatasReq.setFieldName(reqDto.getFieldName());//SimpleFieldAssign//sourceId:1429706_1
fieldsNameAndValueToOneDatasReq.setFieldValue(reqDto.getFieldValue());//SimpleFieldAssign//sourceId:1429707_1
    }

    /*M2执行字段名与值转数据集[8172]  用于将一个字段的字段名与字段值转成数据集 */

      fieldsNameAndValueToOneDatasRes = nbInterfaceMode.implementFieldsNameAndValueToOneDatas(fieldsNameAndValueToOneDatasReq);


      fieldsNameAndValueToOneDatasRes_1 = fieldsNameAndValueToOneDatasRes;

ImplementFieldsNameAndValueToOneDatasComRespDto retData = new ImplementFieldsNameAndValueToOneDatasComRespDto();
  if(fieldsNameAndValueToOneDatasRes_1!=null){
      retData.setFieldsNameAndValueToOneDatasList(fieldsNameAndValueToOneDatasRes_1.getFieldsNameAndValueToOneDatasList().stream().map(item -> BeanUtil.toBean(item, FieldsNameAndValueToOneDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1430386_1
    }




return retData;
  }
/**
   * D2执行时间格式化(公共)[8203]
   * gen by moon at 12/23/2023, 11:08:46 PM
   */
  @Trace(operationName = "D2执行时间格式化(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDateFormatComRespDto implementDateFormatCom(ImplementDateFormatComReqDto reqDto){


      ImplementDateFormatRespDto dateFormatRes_1 =null;
//步骤0: M2执行时间格式化 - implementDateFormat
     //ModelCode: dateFormat
        ImplementDateFormatRespDto dateFormatRes = null;
    ImplementDateFormatReqDto dateFormatReq=new ImplementDateFormatReqDto();
  if(reqDto!=null){
      dateFormatReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:1441530_1
dateFormatReq.setTimeFormatMode(reqDto.getTimeFormatMode());//SimpleFieldAssign//sourceId:1441531_1
    }

    /*M2执行时间格式化[8204]  yyyy-MM-dd: ISO 标准日期格式，例如 2023-12-23。
dd/MM/yyyy: 欧洲/亚洲日期格式，例如 23/12/2023。
MM/dd/yyyy: 美国日期格式，例如 12/23/2023。
yyyy-MM-dd HH:mm:ss: 完整的日期和时间，24小时制，例如 2023-12-23 15:45:30。
dd-MMM-yyyy: 文本月份，例如 23-Dec-2023。
E, MMM dd yyyy: 星期几和日期，例如 Sat, Dec 23 2023。
hh:mm:ss a: 12小时制的时间，带上午/下午标记，例如 03:45:30 PM。
HH:mm:ss: 24小时制的时间，例如 15:45:30。
yyyy-MM-dd'T'HH:mm:ss'Z': ISO 8601 UTC 时间格式，例如 2023-12-23T15:45:30Z。
yyyy-MM-dd HH:mm:ss.SSS: 带毫秒的时间，例如 2023-12-23 15:45:30.123 */
    Assert.isNull(dateFormatReq.getComTimeField(),"D2执行时间格式化(公共)-M2执行时间格式化-通用时间字段不能为空",false);
Assert.isNull(dateFormatReq.getTimeFormatMode(),"D2执行时间格式化(公共)-M2执行时间格式化-时间格式模式不能为空",false);
      dateFormatRes = nbInterfaceMode.implementDateFormat(dateFormatReq);


      dateFormatRes_1 = dateFormatRes;

ImplementDateFormatComRespDto retData = new ImplementDateFormatComRespDto();
  if(dateFormatRes_1!=null){
      retData.setComTxtField(dateFormatRes_1.getComTxtField());//SimpleFieldAssign//sourceId:1441535_1
    }




return retData;
  }
/**
   * D2执行事务等待时长(公共)[8322]
   * gen by moon at 1/22/2024, 11:05:35 PM
   */
  @Trace(operationName = "D2执行事务等待时长(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTransactionWaitingTimeComRespDto implementTransactionWaitingTimeCom(ImplementTransactionWaitingTimeComReqDto reqDto){


      //步骤0: M2执行事务等待时长(特殊方法） - implementTransactionWaitingTime
     //ModelCode: transactionWaitingTime
        ImplementTransactionWaitingTimeRespDto transactionWaitingTimeRes = null;
    ImplementTransactionWaitingTimeReqDto transactionWaitingTimeReq=new ImplementTransactionWaitingTimeReqDto();
  if(reqDto!=null){
      transactionWaitingTimeReq.setWaitingTime(reqDto.getWaitingTime());//SimpleFieldAssign//sourceId:1494570_1
    }

    /*M2执行事务等待时长(特殊方法）[8323]  在一个事务中，插入等待时长后，后续事务需要等待约定的时长后，再继续执行。 */
    Assert.isNull(transactionWaitingTimeReq.getWaitingTime(),"D2执行事务等待时长(公共)-M2执行事务等待时长(特殊方法）-等待时长不能为空",false);
      transactionWaitingTimeRes = nbInterfaceMode.implementTransactionWaitingTime(transactionWaitingTimeReq);




ImplementTransactionWaitingTimeComRespDto retData = new ImplementTransactionWaitingTimeComRespDto();





return retData;
  }
/**
   * D2-执行并发行为主题锁(公共)[8388]
   * gen by moon at 6/2/2024, 10:24:10 PM
   */
  @Trace(operationName = "D2-执行并发行为主题锁(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComCom(ImplementConcBhvThemeLockComComReqDto reqDto){


      ImplementConcBhvThemeLockComRespDto distributedLockingRes_1 =null;
      if((reqDto!= null&&  reqDto.getPreventConcurrentLockingUnlocking() !=null && reqDto.getPreventConcurrentLockingUnlocking().equals("LOCK"))) {
        //if(D2-执行并发行为主题锁(公共).防并发上锁or解锁 等于 上锁)  60482

//ModelCode: distributedLocking
        ImplementConcBhvThemeLockComRespDto distributedLockingRes = null;
    ImplementConcBhvThemeLockComReqDto distributedLockingReq=new ImplementConcBhvThemeLockComReqDto();
  if(reqDto!=null){
      distributedLockingReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819322_1_60484
      distributedLockingReq.setBehaviorThemeLockCode(reqDto.getBehaviorThemeLockCode());//SimpleFieldAssign//sourceId:1517372_1_60484
distributedLockingReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1517371_1_60484
distributedLockingReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1517368_1_60484
distributedLockingReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1517369_1_60484
distributedLockingReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:1517370_1_60484
distributedLockingReq.setDuration(reqDto.getDuration());//SimpleFieldAssign//sourceId:1517373_1_60484
distributedLockingReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1517374_1_60484
    }

    /*M2-执行并发行为主题锁（特殊方法）[8389]   */
    Assert.isNull(distributedLockingReq.getBehaviorThemeLockCode(),"D2-执行并发行为主题锁(公共)-M2-执行并发行为主题锁（特殊方法）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(distributedLockingReq.getCommPrimaryKey(),"D2-执行并发行为主题锁(公共)-M2-执行并发行为主题锁（特殊方法）-通用主键ID不能为空",false);
Assert.isNull(distributedLockingReq.getDuration(),"D2-执行并发行为主题锁(公共)-M2-执行并发行为主题锁（特殊方法）-锁定时长不能为空",false);
Assert.isNull(distributedLockingReq.getTimeUnitType(),"D2-执行并发行为主题锁(公共)-M2-执行并发行为主题锁（特殊方法）-时间单位类型不能为空",false);
      distributedLockingRes = nbInterfaceMode.implementConcBhvThemeLockCom(distributedLockingReq);


      distributedLockingRes_1 = distributedLockingRes;
if((reqDto!= null&&  reqDto.getHandlingMethodConcurrentLockFailure() !=null && reqDto.getHandlingMethodConcurrentLockFailure().equals("CONCURRENT_LOCK_FAILURE_ERROR_REPORTING")&&distributedLockingRes!= null&&  distributedLockingRes.getPreventConcurrentLockingSituations() !=null && distributedLockingRes.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
        //if((D2-执行并发行为主题锁(公共).并发上锁失败处理方式 等于 并发上锁失败报错 and M2-执行并发行为主题锁（特殊方法）.防并发上锁情况 等于 并发上锁失败))  60486

//异常结束 60487
      throw new BizException("C00281","对不起，当前操作繁忙，稍后再来～。",false);
      }
      }
else if((reqDto!= null&&  reqDto.getPreventConcurrentLockingUnlocking() !=null && reqDto.getPreventConcurrentLockingUnlocking().equals("UNLOCK"))){
       //elseif(D2-执行并发行为主题锁(公共).防并发上锁or解锁 等于 解锁)  60483

if((reqDto!= null&&  reqDto.getWhetherUnlockBulk() !=null && reqDto.getWhetherUnlockBulk().equals("TRUE"))) {
        //if(D2-执行并发行为主题锁(公共).是否批量解锁 等于 是)  60489

//ModelCode: distributedBatchUnlock
        ImplementBatchUnlockingConcBhvThemesLockComRespDto distributedBatchUnlockRes = null;
    ImplementBatchUnlockingConcBhvThemesLockComReqDto distributedBatchUnlockReq=new ImplementBatchUnlockingConcBhvThemesLockComReqDto();
  if(reqDto!=null){
      distributedBatchUnlockReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819324_1_60492
      distributedBatchUnlockReq.setBehaviorThemeLockCode(reqDto.getBehaviorThemeLockCode());//SimpleFieldAssign//sourceId:1517392_1_60492
distributedBatchUnlockReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1517393_1_60492
distributedBatchUnlockReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1517394_1_60492
distributedBatchUnlockReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1517395_1_60492
    }

    /*M2-执行批量解锁并发行为主题锁（特殊方法）[8394]  批量解分布式锁 */
    Assert.isNull(distributedBatchUnlockReq.getBehaviorThemeLockCode(),"D2-执行并发行为主题锁(公共)-M2-执行批量解锁并发行为主题锁（特殊方法）-行为主题锁业务数据对象不能为空",false);
      distributedBatchUnlockRes = nbInterfaceMode.implementBatchUnlockingConcBhvThemesLockCom(distributedBatchUnlockReq);



      }
else if((reqDto!= null&&  reqDto.getWhetherUnlockBulk() !=null && reqDto.getWhetherUnlockBulk().equals("FALSE"))){
       //elseif(D2-执行并发行为主题锁(公共).是否批量解锁 等于 否)  60490

//ModelCode: distributedUnlocking
        ImplementUnlockingConcBhvThemesLockComRespDto distributedUnlockingRes = null;
    ImplementUnlockingConcBhvThemesLockComReqDto distributedUnlockingReq=new ImplementUnlockingConcBhvThemesLockComReqDto();
  if(reqDto!=null){
      distributedUnlockingReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819326_1_60491
      distributedUnlockingReq.setBehaviorThemeLockCode(reqDto.getBehaviorThemeLockCode());//SimpleFieldAssign//sourceId:1517401_1_60491
distributedUnlockingReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1517402_1_60491
distributedUnlockingReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1517403_1_60491
distributedUnlockingReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1517404_1_60491
distributedUnlockingReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:1517405_1_60491
    }

    /*M2-执行解锁并发行为主题锁（特殊方法）[8393]   */
    Assert.isNull(distributedUnlockingReq.getBehaviorThemeLockCode(),"D2-执行并发行为主题锁(公共)-M2-执行解锁并发行为主题锁（特殊方法）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(distributedUnlockingReq.getCommPrimaryKey(),"D2-执行并发行为主题锁(公共)-M2-执行解锁并发行为主题锁（特殊方法）-通用主键ID不能为空",false);
      distributedUnlockingRes = nbInterfaceMode.implementUnlockingConcBhvThemesLockCom(distributedUnlockingReq);



    }
    }
ImplementConcBhvThemeLockComComRespDto retData = new ImplementConcBhvThemeLockComComRespDto();
  if(distributedLockingRes_1!=null){
      retData.setPreventConcurrentLockingSituations(distributedLockingRes_1.getPreventConcurrentLockingSituations());//SimpleFieldAssign//sourceId:1521505_1
    }




return retData;
  }
/**
   * D2-新增redis业务数据对象(公共)[8395]
   * gen by moon at 5/31/2024, 8:33:34 PM
   */
  @Trace(operationName = "D2-新增redis业务数据对象(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddRedisBusinessDataComRespDto addRedisBusinessDataCom(AddRedisBusinessDataComReqDto reqDto){


      //步骤0: M2-新增redis业务数据对象（特殊方法） - addRedisBusinessData
     //ModelCode: addRedisBusinessData
        AddRedisBusinessDataRespDto addRedisBusinessDataRes = null;
    AddRedisBusinessDataReqDto addRedisBusinessDataReq=new AddRedisBusinessDataReqDto();
  if(reqDto!=null){
      addRedisBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1517451_1
      addRedisBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1517506_1
addRedisBusinessDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819361_1
addRedisBusinessDataReq.setIsDeleteRedis(reqDto.getIsDeleteRedis());//SimpleFieldAssign//sourceId:1782388_1
addRedisBusinessDataReq.setDuration(reqDto.getDuration());//SimpleFieldAssign//sourceId:1819362_1
addRedisBusinessDataReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1819363_1
addRedisBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1517450_1
    }
if(reqDto!= null&&  reqDto.getFieldDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getFieldDataList())){
      addRedisBusinessDataReq.setFieldDataList(reqDto.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517449_1
    }

    /*M2-新增redis业务数据对象（特殊方法）[8390]   */
    Assert.isNull(addRedisBusinessDataReq.getBusinessDataObject(),"D2-新增redis业务数据对象(公共)-M2-新增redis业务数据对象（特殊方法）-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataReq.getRedisDataObjectCatalogue(),"D2-新增redis业务数据对象(公共)-M2-新增redis业务数据对象（特殊方法）-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataReq.getIsDataList(),"D2-新增redis业务数据对象(公共)-M2-新增redis业务数据对象（特殊方法）-是否是数据集对象不能为空",false);
      addRedisBusinessDataRes = nbInterfaceMode.addRedisBusinessData(addRedisBusinessDataReq);




AddRedisBusinessDataComRespDto retData = new AddRedisBusinessDataComRespDto();





return retData;
  }
/**
   * D2-查询redis业务数据对象列表(公共)[8396]
   * gen by moon at 5/31/2024, 8:33:43 PM
   */
  @Trace(operationName = "D2-查询redis业务数据对象列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryRedisBusinessDataListComRespDto queryRedisBusinessDataListCom(QueryRedisBusinessDataListComReqDto reqDto){


      QueryRedisBusinessDataListRespDto queryRedisBusinessDataRes_1 =null;
//步骤0: M2-查询redis业务数据对象列表（特殊方法） - queryRedisBusinessDataList
     //ModelCode: queryRedisBusinessData
        QueryRedisBusinessDataListRespDto queryRedisBusinessDataRes = null;
    QueryRedisBusinessDataListReqDto queryRedisBusinessDataReq=new QueryRedisBusinessDataListReqDto();
  if(reqDto!=null){
      queryRedisBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1517516_1
queryRedisBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1517465_1
queryRedisBusinessDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819381_1
    }
if(reqDto!= null&&  reqDto.getRedisBusinessDataResList() !=null&& !CollectionUtil.isEmpty(reqDto.getRedisBusinessDataResList())){
      queryRedisBusinessDataReq.setRedisBusinessDataResList(reqDto.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517682_1
    }

    /*M2-查询redis业务数据对象列表（特殊方法）[8391]   */
    Assert.isNull(queryRedisBusinessDataReq.getDataObjectBatchCode(),"D2-查询redis业务数据对象列表(公共)-M2-查询redis业务数据对象列表（特殊方法）-数据对象批次标识不能为空",false);
Assert.isNull(queryRedisBusinessDataReq.getBusinessDataObject(),"D2-查询redis业务数据对象列表(公共)-M2-查询redis业务数据对象列表（特殊方法）-业务数据对象不能为空",false);
Assert.isNull(queryRedisBusinessDataReq.getRedisDataObjectCatalogue(),"D2-查询redis业务数据对象列表(公共)-M2-查询redis业务数据对象列表（特殊方法）-Redis数据对象目录不能为空",false);
      queryRedisBusinessDataRes = nbInterfaceMode.queryRedisBusinessDataList(queryRedisBusinessDataReq);


      queryRedisBusinessDataRes_1 = queryRedisBusinessDataRes;

QueryRedisBusinessDataListComRespDto retData = new QueryRedisBusinessDataListComRespDto();
  if(queryRedisBusinessDataRes_1!=null){
      retData.setRedisBusinessDataResList(queryRedisBusinessDataRes_1.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517686_1
    }




return retData;
  }
/**
   * D2-删除redis业务数据对象(公共)[8397]
   * gen by moon at 5/31/2024, 8:33:50 PM
   */
  @Trace(operationName = "D2-删除redis业务数据对象(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteRedisBusinessDataComRespDto deleteRedisBusinessDataCom(DeleteRedisBusinessDataComReqDto reqDto){


      //步骤0: M2-删除redis业务数据对象（特殊方法） - deleteRedisBusinessData
     //ModelCode: deleteRedisBusinessData
        DeleteRedisBusinessDataRespDto deleteRedisBusinessDataRes = null;
    DeleteRedisBusinessDataReqDto deleteRedisBusinessDataReq=new DeleteRedisBusinessDataReqDto();
  if(reqDto!=null){
      deleteRedisBusinessDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1820568_1
      deleteRedisBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1517510_1
deleteRedisBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1517470_1
deleteRedisBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1517511_1
    }
if(reqDto!= null&&  reqDto.getFieldDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getFieldDataList())){
      deleteRedisBusinessDataReq.setFieldDataList(reqDto.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517471_1
    }

    /*M2-删除redis业务数据对象（特殊方法）[8392]   */
    Assert.isNull(deleteRedisBusinessDataReq.getRedisDataObjectCatalogue(),"D2-删除redis业务数据对象(公共)-M2-删除redis业务数据对象（特殊方法）-Redis数据对象目录不能为空",false);
Assert.isNull(deleteRedisBusinessDataReq.getBusinessDataObject(),"D2-删除redis业务数据对象(公共)-M2-删除redis业务数据对象（特殊方法）-业务数据对象不能为空",false);
Assert.isNull(deleteRedisBusinessDataReq.getIsDataList(),"D2-删除redis业务数据对象(公共)-M2-删除redis业务数据对象（特殊方法）-是否是数据集对象不能为空",false);
      deleteRedisBusinessDataRes = nbInterfaceMode.deleteRedisBusinessData(deleteRedisBusinessDataReq);




DeleteRedisBusinessDataComRespDto retData = new DeleteRedisBusinessDataComRespDto();





return retData;
  }
/**
   * D2-查询redis业务数据对象详情(公共)[8401]
   * gen by moon at 5/31/2024, 8:34:04 PM
   */
  @Trace(operationName = "D2-查询redis业务数据对象详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryRedisBusinessDataDetailComRespDto queryRedisBusinessDataDetailCom(QueryRedisBusinessDataDetailComReqDto reqDto){


      QueryRedisBusinessDataDetailRespDto queryRedisBusinessDataObjectRes_1 =null;
//步骤0: M2-查询redis业务数据对象详情（特殊方法） - queryRedisBusinessDataDetail
     //ModelCode: queryRedisBusinessDataObject
        QueryRedisBusinessDataDetailRespDto queryRedisBusinessDataObjectRes = null;
    QueryRedisBusinessDataDetailReqDto queryRedisBusinessDataObjectReq=new QueryRedisBusinessDataDetailReqDto();
  if(reqDto!=null){
      queryRedisBusinessDataObjectReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1517747_1
queryRedisBusinessDataObjectReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1517746_1
queryRedisBusinessDataObjectReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819376_1
    }
if(reqDto!= null&&  reqDto.getRedisBusinessDataResList() !=null&& !CollectionUtil.isEmpty(reqDto.getRedisBusinessDataResList())){
      queryRedisBusinessDataObjectReq.setRedisBusinessDataResList(reqDto.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517745_1
    }

    /*M2-查询redis业务数据对象详情（特殊方法）[8402]   */
    Assert.isNull(queryRedisBusinessDataObjectReq.getDataObjectBatchCode(),"D2-查询redis业务数据对象详情(公共)-M2-查询redis业务数据对象详情（特殊方法）-数据对象批次标识不能为空",false);
Assert.isNull(queryRedisBusinessDataObjectReq.getBusinessDataObject(),"D2-查询redis业务数据对象详情(公共)-M2-查询redis业务数据对象详情（特殊方法）-业务数据对象不能为空",false);
Assert.isNull(queryRedisBusinessDataObjectReq.getRedisDataObjectCatalogue(),"D2-查询redis业务数据对象详情(公共)-M2-查询redis业务数据对象详情（特殊方法）-Redis数据对象目录不能为空",false);
      queryRedisBusinessDataObjectRes = nbInterfaceMode.queryRedisBusinessDataDetail(queryRedisBusinessDataObjectReq);


      queryRedisBusinessDataObjectRes_1 = queryRedisBusinessDataObjectRes;

QueryRedisBusinessDataDetailComRespDto retData = new QueryRedisBusinessDataDetailComRespDto();
  if(queryRedisBusinessDataObjectRes_1!=null){
      retData.setCustomField1(queryRedisBusinessDataObjectRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1517801_1
retData.setCustomField2(queryRedisBusinessDataObjectRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1517802_1
retData.setCustomField3(queryRedisBusinessDataObjectRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1517803_1
retData.setCustomField4(queryRedisBusinessDataObjectRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1517804_1
retData.setCustomField5(queryRedisBusinessDataObjectRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1517805_1
retData.setCustomField7(queryRedisBusinessDataObjectRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1517806_1
retData.setCustomField6(queryRedisBusinessDataObjectRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1517807_1
retData.setCustomField8(queryRedisBusinessDataObjectRes_1.getCustomField8());//SimpleFieldAssign//sourceId:1517808_1
retData.setCustomField9(queryRedisBusinessDataObjectRes_1.getCustomField9());//SimpleFieldAssign//sourceId:1517809_1
retData.setCustomField10(queryRedisBusinessDataObjectRes_1.getCustomField10());//SimpleFieldAssign//sourceId:1517810_1
retData.setCustomField11(queryRedisBusinessDataObjectRes_1.getCustomField11());//SimpleFieldAssign//sourceId:1517811_1
retData.setCustomField12(queryRedisBusinessDataObjectRes_1.getCustomField12());//SimpleFieldAssign//sourceId:1517812_1
retData.setCustomField13(queryRedisBusinessDataObjectRes_1.getCustomField13());//SimpleFieldAssign//sourceId:1517813_1
retData.setCustomField14(queryRedisBusinessDataObjectRes_1.getCustomField14());//SimpleFieldAssign//sourceId:1517814_1
retData.setCustomField15(queryRedisBusinessDataObjectRes_1.getCustomField15());//SimpleFieldAssign//sourceId:1517815_1
retData.setCustomField16(queryRedisBusinessDataObjectRes_1.getCustomField16());//SimpleFieldAssign//sourceId:1517816_1
retData.setCustomField17(queryRedisBusinessDataObjectRes_1.getCustomField17());//SimpleFieldAssign//sourceId:1517817_1
retData.setCustomField18(queryRedisBusinessDataObjectRes_1.getCustomField18());//SimpleFieldAssign//sourceId:1517818_1
retData.setCustomField19(queryRedisBusinessDataObjectRes_1.getCustomField19());//SimpleFieldAssign//sourceId:1517819_1
retData.setCustomField20(queryRedisBusinessDataObjectRes_1.getCustomField20());//SimpleFieldAssign//sourceId:1517820_1
retData.setCustomField21(queryRedisBusinessDataObjectRes_1.getCustomField21());//SimpleFieldAssign//sourceId:1517821_1
retData.setCustomField22(queryRedisBusinessDataObjectRes_1.getCustomField22());//SimpleFieldAssign//sourceId:1517822_1
retData.setCustomField23(queryRedisBusinessDataObjectRes_1.getCustomField23());//SimpleFieldAssign//sourceId:1517823_1
retData.setCustomField24(queryRedisBusinessDataObjectRes_1.getCustomField24());//SimpleFieldAssign//sourceId:1517824_1
retData.setCustomField25(queryRedisBusinessDataObjectRes_1.getCustomField25());//SimpleFieldAssign//sourceId:1517825_1
retData.setCustomField26(queryRedisBusinessDataObjectRes_1.getCustomField26());//SimpleFieldAssign//sourceId:1517826_1
retData.setCustomField27(queryRedisBusinessDataObjectRes_1.getCustomField27());//SimpleFieldAssign//sourceId:1517827_1
retData.setCustomField28(queryRedisBusinessDataObjectRes_1.getCustomField28());//SimpleFieldAssign//sourceId:1517828_1
retData.setCustomField29(queryRedisBusinessDataObjectRes_1.getCustomField29());//SimpleFieldAssign//sourceId:1517829_1
retData.setCustomField30(queryRedisBusinessDataObjectRes_1.getCustomField30());//SimpleFieldAssign//sourceId:1517830_1
retData.setCustomField31(queryRedisBusinessDataObjectRes_1.getCustomField31());//SimpleFieldAssign//sourceId:1517831_1
retData.setCustomField32(queryRedisBusinessDataObjectRes_1.getCustomField32());//SimpleFieldAssign//sourceId:1517832_1
retData.setCustomField33(queryRedisBusinessDataObjectRes_1.getCustomField33());//SimpleFieldAssign//sourceId:1517833_1
retData.setCustomField34(queryRedisBusinessDataObjectRes_1.getCustomField34());//SimpleFieldAssign//sourceId:1517834_1
retData.setCustomField35(queryRedisBusinessDataObjectRes_1.getCustomField35());//SimpleFieldAssign//sourceId:1517835_1
retData.setCustomField36(queryRedisBusinessDataObjectRes_1.getCustomField36());//SimpleFieldAssign//sourceId:1517836_1
retData.setCustomField37(queryRedisBusinessDataObjectRes_1.getCustomField37());//SimpleFieldAssign//sourceId:1517837_1
retData.setCustomField38(queryRedisBusinessDataObjectRes_1.getCustomField38());//SimpleFieldAssign//sourceId:1517838_1
retData.setCustomField39(queryRedisBusinessDataObjectRes_1.getCustomField39());//SimpleFieldAssign//sourceId:1517839_1
retData.setCustomField40(queryRedisBusinessDataObjectRes_1.getCustomField40());//SimpleFieldAssign//sourceId:1517840_1
retData.setCustomField41(queryRedisBusinessDataObjectRes_1.getCustomField41());//SimpleFieldAssign//sourceId:1517841_1
retData.setCustomField42(queryRedisBusinessDataObjectRes_1.getCustomField42());//SimpleFieldAssign//sourceId:1517842_1
retData.setCustomField43(queryRedisBusinessDataObjectRes_1.getCustomField43());//SimpleFieldAssign//sourceId:1517843_1
retData.setCustomField44(queryRedisBusinessDataObjectRes_1.getCustomField44());//SimpleFieldAssign//sourceId:1517844_1
retData.setCustomField45(queryRedisBusinessDataObjectRes_1.getCustomField45());//SimpleFieldAssign//sourceId:1517845_1
retData.setCustomField46(queryRedisBusinessDataObjectRes_1.getCustomField46());//SimpleFieldAssign//sourceId:1517846_1
retData.setCustomField47(queryRedisBusinessDataObjectRes_1.getCustomField47());//SimpleFieldAssign//sourceId:1517847_1
retData.setCustomField48(queryRedisBusinessDataObjectRes_1.getCustomField48());//SimpleFieldAssign//sourceId:1517848_1
retData.setCustomField49(queryRedisBusinessDataObjectRes_1.getCustomField49());//SimpleFieldAssign//sourceId:1517849_1
retData.setCustomField50(queryRedisBusinessDataObjectRes_1.getCustomField50());//SimpleFieldAssign//sourceId:1517850_1
    }




return retData;
  }
/**
   * D2-分析单字段批量转数据集(公共)[8405]
   * gen by moon at 10/23/2024, 6:13:37 PM
   */
  @Trace(operationName = "D2-分析单字段批量转数据集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisFieldBatchDataComRespDto analysisFieldBatchDataCom(AnalysisFieldBatchDataComReqDto reqDto){


      AnalysisFieldBatchDataRespDto fieldBatchDataRes_1 =null;
//步骤0: M2-分析单字段批量转数据集（特殊方法） - analysisFieldBatchData
     //ModelCode: fieldBatchData
        AnalysisFieldBatchDataRespDto fieldBatchDataRes = null;
    AnalysisFieldBatchDataReqDto fieldBatchDataReq=new AnalysisFieldBatchDataReqDto();
  if(reqDto!=null){
      fieldBatchDataReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1518019_1
fieldBatchDataReq.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:1518020_1
fieldBatchDataReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1518021_1
fieldBatchDataReq.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:1518022_1
fieldBatchDataReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:1518023_1
fieldBatchDataReq.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:1518024_1
fieldBatchDataReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:1518025_1
fieldBatchDataReq.setCustomFieldValue4(reqDto.getCustomFieldValue4());//SimpleFieldAssign//sourceId:1518026_1
fieldBatchDataReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:1518027_1
fieldBatchDataReq.setCustomFieldValue5(reqDto.getCustomFieldValue5());//SimpleFieldAssign//sourceId:1518028_1
fieldBatchDataReq.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:1518029_1
fieldBatchDataReq.setCustomFieldValue6(reqDto.getCustomFieldValue6());//SimpleFieldAssign//sourceId:1518030_1
fieldBatchDataReq.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:1518031_1
fieldBatchDataReq.setCustomFieldValue7(reqDto.getCustomFieldValue7());//SimpleFieldAssign//sourceId:1518032_1
fieldBatchDataReq.setCustomField8(reqDto.getCustomField8());//SimpleFieldAssign//sourceId:1518033_1
fieldBatchDataReq.setCustomFieldValue8(reqDto.getCustomFieldValue8());//SimpleFieldAssign//sourceId:1518034_1
fieldBatchDataReq.setCustomField9(reqDto.getCustomField9());//SimpleFieldAssign//sourceId:1518035_1
fieldBatchDataReq.setCustomFieldValue9(reqDto.getCustomFieldValue9());//SimpleFieldAssign//sourceId:1518036_1
fieldBatchDataReq.setCustomField10(reqDto.getCustomField10());//SimpleFieldAssign//sourceId:1518037_1
fieldBatchDataReq.setCustomFieldValue10(reqDto.getCustomFieldValue10());//SimpleFieldAssign//sourceId:1518038_1
fieldBatchDataReq.setCustomField11(reqDto.getCustomField11());//SimpleFieldAssign//sourceId:1518039_1
fieldBatchDataReq.setCustomFieldValue11(reqDto.getCustomFieldValue11());//SimpleFieldAssign//sourceId:1518040_1
fieldBatchDataReq.setCustomField12(reqDto.getCustomField12());//SimpleFieldAssign//sourceId:1518041_1
fieldBatchDataReq.setCustomFieldValue12(reqDto.getCustomFieldValue12());//SimpleFieldAssign//sourceId:1518042_1
fieldBatchDataReq.setCustomField13(reqDto.getCustomField13());//SimpleFieldAssign//sourceId:1518043_1
fieldBatchDataReq.setCustomFieldValue13(reqDto.getCustomFieldValue13());//SimpleFieldAssign//sourceId:1518044_1
fieldBatchDataReq.setCustomField14(reqDto.getCustomField14());//SimpleFieldAssign//sourceId:1518045_1
fieldBatchDataReq.setCustomFieldValue14(reqDto.getCustomFieldValue14());//SimpleFieldAssign//sourceId:1518046_1
fieldBatchDataReq.setCustomField15(reqDto.getCustomField15());//SimpleFieldAssign//sourceId:1518047_1
fieldBatchDataReq.setCustomFieldValue15(reqDto.getCustomFieldValue15());//SimpleFieldAssign//sourceId:1518048_1
fieldBatchDataReq.setCustomField16(reqDto.getCustomField16());//SimpleFieldAssign//sourceId:1518049_1
fieldBatchDataReq.setCustomFieldValue16(reqDto.getCustomFieldValue16());//SimpleFieldAssign//sourceId:1518050_1
fieldBatchDataReq.setCustomField17(reqDto.getCustomField17());//SimpleFieldAssign//sourceId:1518051_1
fieldBatchDataReq.setCustomFieldValue17(reqDto.getCustomFieldValue17());//SimpleFieldAssign//sourceId:1518052_1
fieldBatchDataReq.setCustomField18(reqDto.getCustomField18());//SimpleFieldAssign//sourceId:1518053_1
fieldBatchDataReq.setCustomFieldValue18(reqDto.getCustomFieldValue18());//SimpleFieldAssign//sourceId:1518054_1
fieldBatchDataReq.setCustomField19(reqDto.getCustomField19());//SimpleFieldAssign//sourceId:1518055_1
fieldBatchDataReq.setCustomFieldValue19(reqDto.getCustomFieldValue19());//SimpleFieldAssign//sourceId:1518095_1
fieldBatchDataReq.setCustomField20(reqDto.getCustomField20());//SimpleFieldAssign//sourceId:1518056_1
fieldBatchDataReq.setCustomFieldValue20(reqDto.getCustomFieldValue20());//SimpleFieldAssign//sourceId:1518096_1
fieldBatchDataReq.setCustomField21(reqDto.getCustomField21());//SimpleFieldAssign//sourceId:1518057_1
fieldBatchDataReq.setCustomFieldValue21(reqDto.getCustomFieldValue21());//SimpleFieldAssign//sourceId:1518097_1
fieldBatchDataReq.setCustomField22(reqDto.getCustomField22());//SimpleFieldAssign//sourceId:1518058_1
fieldBatchDataReq.setCustomFieldValue22(reqDto.getCustomFieldValue22());//SimpleFieldAssign//sourceId:1518098_1
fieldBatchDataReq.setCustomField23(reqDto.getCustomField23());//SimpleFieldAssign//sourceId:1518059_1
fieldBatchDataReq.setCustomFieldValue23(reqDto.getCustomFieldValue23());//SimpleFieldAssign//sourceId:1518099_1
fieldBatchDataReq.setCustomField24(reqDto.getCustomField24());//SimpleFieldAssign//sourceId:1518060_1
fieldBatchDataReq.setCustomFieldValue24(reqDto.getCustomFieldValue24());//SimpleFieldAssign//sourceId:1518100_1
fieldBatchDataReq.setCustomField25(reqDto.getCustomField25());//SimpleFieldAssign//sourceId:1518061_1
fieldBatchDataReq.setCustomFieldValue25(reqDto.getCustomFieldValue25());//SimpleFieldAssign//sourceId:1518101_1
fieldBatchDataReq.setCustomField26(reqDto.getCustomField26());//SimpleFieldAssign//sourceId:1518062_1
fieldBatchDataReq.setCustomFieldValue26(reqDto.getCustomFieldValue26());//SimpleFieldAssign//sourceId:1518102_1
fieldBatchDataReq.setCustomField27(reqDto.getCustomField27());//SimpleFieldAssign//sourceId:1518063_1
fieldBatchDataReq.setCustomFieldValue27(reqDto.getCustomFieldValue27());//SimpleFieldAssign//sourceId:1518103_1
fieldBatchDataReq.setCustomField28(reqDto.getCustomField28());//SimpleFieldAssign//sourceId:1518064_1
fieldBatchDataReq.setCustomFieldValue28(reqDto.getCustomFieldValue28());//SimpleFieldAssign//sourceId:1518104_1
fieldBatchDataReq.setCustomField29(reqDto.getCustomField29());//SimpleFieldAssign//sourceId:1518065_1
fieldBatchDataReq.setCustomFieldValue29(reqDto.getCustomFieldValue29());//SimpleFieldAssign//sourceId:1518105_1
fieldBatchDataReq.setCustomField30(reqDto.getCustomField30());//SimpleFieldAssign//sourceId:1518066_1
fieldBatchDataReq.setCustomFieldValue30(reqDto.getCustomFieldValue30());//SimpleFieldAssign//sourceId:1518106_1
fieldBatchDataReq.setCustomField31(reqDto.getCustomField31());//SimpleFieldAssign//sourceId:1518067_1
fieldBatchDataReq.setCustomFieldValue31(reqDto.getCustomFieldValue31());//SimpleFieldAssign//sourceId:1518107_1
fieldBatchDataReq.setCustomField32(reqDto.getCustomField32());//SimpleFieldAssign//sourceId:1518068_1
fieldBatchDataReq.setCustomFieldValue32(reqDto.getCustomFieldValue32());//SimpleFieldAssign//sourceId:1518108_1
fieldBatchDataReq.setCustomField33(reqDto.getCustomField33());//SimpleFieldAssign//sourceId:1518069_1
fieldBatchDataReq.setCustomFieldValue33(reqDto.getCustomFieldValue33());//SimpleFieldAssign//sourceId:1518109_1
fieldBatchDataReq.setCustomField34(reqDto.getCustomField34());//SimpleFieldAssign//sourceId:1518070_1
fieldBatchDataReq.setCustomFieldValue34(reqDto.getCustomFieldValue34());//SimpleFieldAssign//sourceId:1518110_1
fieldBatchDataReq.setCustomField35(reqDto.getCustomField35());//SimpleFieldAssign//sourceId:1518071_1
fieldBatchDataReq.setCustomFieldValue35(reqDto.getCustomFieldValue35());//SimpleFieldAssign//sourceId:1518111_1
fieldBatchDataReq.setCustomField36(reqDto.getCustomField36());//SimpleFieldAssign//sourceId:1518072_1
fieldBatchDataReq.setCustomFieldValue36(reqDto.getCustomFieldValue36());//SimpleFieldAssign//sourceId:1518112_1
fieldBatchDataReq.setCustomField37(reqDto.getCustomField37());//SimpleFieldAssign//sourceId:1518073_1
fieldBatchDataReq.setCustomFieldValue37(reqDto.getCustomFieldValue37());//SimpleFieldAssign//sourceId:1518113_1
fieldBatchDataReq.setCustomField38(reqDto.getCustomField38());//SimpleFieldAssign//sourceId:1518074_1
fieldBatchDataReq.setCustomFieldValue38(reqDto.getCustomFieldValue38());//SimpleFieldAssign//sourceId:1518114_1
fieldBatchDataReq.setCustomField39(reqDto.getCustomField39());//SimpleFieldAssign//sourceId:1518075_1
fieldBatchDataReq.setCustomFieldValue39(reqDto.getCustomFieldValue39());//SimpleFieldAssign//sourceId:1518115_1
fieldBatchDataReq.setCustomField40(reqDto.getCustomField40());//SimpleFieldAssign//sourceId:1518076_1
fieldBatchDataReq.setCustomFieldValue40(reqDto.getCustomFieldValue40());//SimpleFieldAssign//sourceId:1518116_1
fieldBatchDataReq.setCustomField41(reqDto.getCustomField41());//SimpleFieldAssign//sourceId:1518077_1
fieldBatchDataReq.setCustomFieldValue41(reqDto.getCustomFieldValue41());//SimpleFieldAssign//sourceId:1518117_1
fieldBatchDataReq.setCustomField42(reqDto.getCustomField42());//SimpleFieldAssign//sourceId:1518078_1
fieldBatchDataReq.setCustomFieldValue42(reqDto.getCustomFieldValue42());//SimpleFieldAssign//sourceId:1518118_1
fieldBatchDataReq.setCustomField43(reqDto.getCustomField43());//SimpleFieldAssign//sourceId:1518079_1
fieldBatchDataReq.setCustomFieldValue43(reqDto.getCustomFieldValue43());//SimpleFieldAssign//sourceId:1518087_1
fieldBatchDataReq.setCustomField44(reqDto.getCustomField44());//SimpleFieldAssign//sourceId:1518080_1
fieldBatchDataReq.setCustomFieldValue44(reqDto.getCustomFieldValue44());//SimpleFieldAssign//sourceId:1518088_1
fieldBatchDataReq.setCustomField45(reqDto.getCustomField45());//SimpleFieldAssign//sourceId:1518081_1
fieldBatchDataReq.setCustomFieldValue45(reqDto.getCustomFieldValue45());//SimpleFieldAssign//sourceId:1518089_1
fieldBatchDataReq.setCustomField46(reqDto.getCustomField46());//SimpleFieldAssign//sourceId:1518082_1
fieldBatchDataReq.setCustomFieldValue46(reqDto.getCustomFieldValue46());//SimpleFieldAssign//sourceId:1518090_1
fieldBatchDataReq.setCustomField47(reqDto.getCustomField47());//SimpleFieldAssign//sourceId:1518083_1
fieldBatchDataReq.setCustomFieldValue47(reqDto.getCustomFieldValue47());//SimpleFieldAssign//sourceId:1518091_1
fieldBatchDataReq.setCustomField48(reqDto.getCustomField48());//SimpleFieldAssign//sourceId:1518084_1
fieldBatchDataReq.setCustomFieldValue48(reqDto.getCustomFieldValue48());//SimpleFieldAssign//sourceId:1518092_1
fieldBatchDataReq.setCustomField49(reqDto.getCustomField49());//SimpleFieldAssign//sourceId:1518085_1
fieldBatchDataReq.setCustomFieldValue49(reqDto.getCustomFieldValue49());//SimpleFieldAssign//sourceId:1518093_1
fieldBatchDataReq.setCustomField50(reqDto.getCustomField50());//SimpleFieldAssign//sourceId:1518086_1
fieldBatchDataReq.setCustomFieldValue50(reqDto.getCustomFieldValue50());//SimpleFieldAssign//sourceId:1518094_1
fieldBatchDataReq.setCustomField51(reqDto.getCustomField51());//SimpleFieldAssign//sourceId:1834665_1
fieldBatchDataReq.setCustomFieldValue51(reqDto.getCustomFieldValue51());//SimpleFieldAssign//sourceId:1834666_1
fieldBatchDataReq.setCustomField52(reqDto.getCustomField52());//SimpleFieldAssign//sourceId:1834667_1
fieldBatchDataReq.setCustomFieldValue52(reqDto.getCustomFieldValue52());//SimpleFieldAssign//sourceId:1834668_1
fieldBatchDataReq.setCustomField53(reqDto.getCustomField53());//SimpleFieldAssign//sourceId:1834669_1
fieldBatchDataReq.setCustomFieldValue53(reqDto.getCustomFieldValue53());//SimpleFieldAssign//sourceId:1834670_1
fieldBatchDataReq.setCustomField54(reqDto.getCustomField54());//SimpleFieldAssign//sourceId:1834671_1
fieldBatchDataReq.setCustomFieldValue54(reqDto.getCustomFieldValue54());//SimpleFieldAssign//sourceId:1834672_1
fieldBatchDataReq.setCustomField55(reqDto.getCustomField55());//SimpleFieldAssign//sourceId:1834673_1
fieldBatchDataReq.setCustomFieldValue55(reqDto.getCustomFieldValue55());//SimpleFieldAssign//sourceId:1834674_1
fieldBatchDataReq.setCustomField56(reqDto.getCustomField56());//SimpleFieldAssign//sourceId:1834675_1
fieldBatchDataReq.setCustomFieldValue56(reqDto.getCustomFieldValue56());//SimpleFieldAssign//sourceId:1834676_1
fieldBatchDataReq.setCustomField57(reqDto.getCustomField57());//SimpleFieldAssign//sourceId:2022541_1
fieldBatchDataReq.setCustomFieldValue57(reqDto.getCustomFieldValue57());//SimpleFieldAssign//sourceId:2022542_1
fieldBatchDataReq.setCustomField58(reqDto.getCustomField58());//SimpleFieldAssign//sourceId:2022543_1
fieldBatchDataReq.setCustomFieldValue58(reqDto.getCustomFieldValue58());//SimpleFieldAssign//sourceId:2022544_1
fieldBatchDataReq.setCustomField59(reqDto.getCustomField59());//SimpleFieldAssign//sourceId:2022545_1
fieldBatchDataReq.setCustomFieldValue59(reqDto.getCustomFieldValue59());//SimpleFieldAssign//sourceId:2022546_1
fieldBatchDataReq.setCustomField60(reqDto.getCustomField60());//SimpleFieldAssign//sourceId:2022547_1
fieldBatchDataReq.setCustomFieldValue60(reqDto.getCustomFieldValue60());//SimpleFieldAssign//sourceId:2022548_1
    }

    /*M2-分析单字段批量转数据集（特殊方法）[8403]   */

      fieldBatchDataRes = nbInterfaceMode.analysisFieldBatchData(fieldBatchDataReq);


      fieldBatchDataRes_1 = fieldBatchDataRes;

AnalysisFieldBatchDataComRespDto retData = new AnalysisFieldBatchDataComRespDto();
  if(fieldBatchDataRes_1!=null){
      retData.setFieldBatchDataList(fieldBatchDataRes_1.getFieldBatchDataList().stream().map(item -> BeanUtil.toBean(item, FieldBatchDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1518220_1
    }




return retData;
  }
/**
   * D2-查询入参redis业务数据对象列表(公共)[8441]
   * gen by moon at 5/31/2024, 8:34:25 PM
   */
  @Trace(operationName = "D2-查询入参redis业务数据对象列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryRefRedisBusinessDataListComRespDto queryRefRedisBusinessDataListCom(QueryRefRedisBusinessDataListComReqDto reqDto){


      QueryRefRedisBusinessDataListRespDto queryRedisBusinessSomeDataRes_1 =null;
//步骤0: M2-查询入参redis业务数据对象列表（特殊方法） - queryRefRedisBusinessDataList
     //ModelCode: queryRedisBusinessSomeData
        QueryRefRedisBusinessDataListRespDto queryRedisBusinessSomeDataRes = null;
    QueryRefRedisBusinessDataListReqDto queryRedisBusinessSomeDataReq=new QueryRefRedisBusinessDataListReqDto();
  if(reqDto!=null){
      queryRedisBusinessSomeDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1525990_1
queryRedisBusinessSomeDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1525991_1
queryRedisBusinessSomeDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819386_1
queryRedisBusinessSomeDataReq.setBatchQueryRefDataFieldName(reqDto.getBatchQueryRefDataFieldName());//SimpleFieldAssign//sourceId:1536581_1
queryRedisBusinessSomeDataReq.setRefRedisBusinessDataList(reqDto.getRefRedisBusinessDataList());//list-field-assign//sourceId:1527594_1
queryRedisBusinessSomeDataReq.setRefCustomField1(reqDto.getRefCustomField1());//SimpleFieldAssign//sourceId:1525994_1
queryRedisBusinessSomeDataReq.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1537497_1
queryRedisBusinessSomeDataReq.setRefCustomField2(reqDto.getRefCustomField2());//SimpleFieldAssign//sourceId:1525995_1
queryRedisBusinessSomeDataReq.setRefCustomFieldValue2(reqDto.getRefCustomFieldValue2());//SimpleFieldAssign//sourceId:1537498_1
queryRedisBusinessSomeDataReq.setRefCustomField3(reqDto.getRefCustomField3());//SimpleFieldAssign//sourceId:1525996_1
queryRedisBusinessSomeDataReq.setRefCustomFieldValue3(reqDto.getRefCustomFieldValue3());//SimpleFieldAssign//sourceId:1537499_1
queryRedisBusinessSomeDataReq.setRefCustomField4(reqDto.getRefCustomField4());//SimpleFieldAssign//sourceId:1525997_1
queryRedisBusinessSomeDataReq.setRefCustomFieldValue4(reqDto.getRefCustomFieldValue4());//SimpleFieldAssign//sourceId:1537500_1
queryRedisBusinessSomeDataReq.setRefCustomField5(reqDto.getRefCustomField5());//SimpleFieldAssign//sourceId:1525998_1
queryRedisBusinessSomeDataReq.setRefCustomFieldValue5(reqDto.getRefCustomFieldValue5());//SimpleFieldAssign//sourceId:1537501_1
queryRedisBusinessSomeDataReq.setRefCustomField6(reqDto.getRefCustomField6());//SimpleFieldAssign//sourceId:1525999_1
queryRedisBusinessSomeDataReq.setRefCustomFieldValue6(reqDto.getRefCustomFieldValue6());//SimpleFieldAssign//sourceId:1537502_1
queryRedisBusinessSomeDataReq.setRefCustomField7(reqDto.getRefCustomField7());//SimpleFieldAssign//sourceId:1526000_1
queryRedisBusinessSomeDataReq.setRefCustomFieldValue7(reqDto.getRefCustomFieldValue7());//SimpleFieldAssign//sourceId:1537503_1
queryRedisBusinessSomeDataReq.setRefCustomField8(reqDto.getRefCustomField8());//SimpleFieldAssign//sourceId:1526001_1
queryRedisBusinessSomeDataReq.setRefCustomFieldValue8(reqDto.getRefCustomFieldValue8());//SimpleFieldAssign//sourceId:1537504_1
    }
if(reqDto!= null&&  reqDto.getRedisBusinessDataResList() !=null&& !CollectionUtil.isEmpty(reqDto.getRedisBusinessDataResList())){
      queryRedisBusinessSomeDataReq.setRedisBusinessDataResList(reqDto.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1525992_1
    }

    /*M2-查询入参redis业务数据对象列表（特殊方法）[8442]   */
    Assert.isNull(queryRedisBusinessSomeDataReq.getBusinessDataObject(),"D2-查询入参redis业务数据对象列表(公共)-M2-查询入参redis业务数据对象列表（特殊方法）-业务数据对象不能为空",false);
Assert.isNull(queryRedisBusinessSomeDataReq.getDataObjectBatchCode(),"D2-查询入参redis业务数据对象列表(公共)-M2-查询入参redis业务数据对象列表（特殊方法）-数据对象批次标识不能为空",false);
Assert.isNull(queryRedisBusinessSomeDataReq.getRedisDataObjectCatalogue(),"D2-查询入参redis业务数据对象列表(公共)-M2-查询入参redis业务数据对象列表（特殊方法）-Redis数据对象目录不能为空",false);
      queryRedisBusinessSomeDataRes = nbInterfaceMode.queryRefRedisBusinessDataList(queryRedisBusinessSomeDataReq);


      queryRedisBusinessSomeDataRes_1 = queryRedisBusinessSomeDataRes;

QueryRefRedisBusinessDataListComRespDto retData = new QueryRefRedisBusinessDataListComRespDto();
  if(queryRedisBusinessSomeDataRes_1!=null){
      retData.setRedisBusinessDataResList(queryRedisBusinessSomeDataRes_1.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1526013_1
    }




return retData;
  }
/**
   * D2-查询入参redis业务数据对象详情(公共)[8475]
   * gen by moon at 6/3/2024, 10:53:33 PM
   */
  @Trace(operationName = "D2-查询入参redis业务数据对象详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryRefRedisBusinessDataDetailComRespDto queryRefRedisBusinessDataDetailCom(QueryRefRedisBusinessDataDetailComReqDto reqDto){


      QueryRefRedisBusinessDataDetailRespDto queryRedisBusinessOneDataRes_1 =null;
//步骤0: M2-查询入参redis业务数据对象详情（特殊方法） - queryRefRedisBusinessDataDetail
     //ModelCode: queryRedisBusinessOneData
        QueryRefRedisBusinessDataDetailRespDto queryRedisBusinessOneDataRes = null;
    QueryRefRedisBusinessDataDetailReqDto queryRedisBusinessOneDataReq=new QueryRefRedisBusinessDataDetailReqDto();
  if(reqDto!=null){
      queryRedisBusinessOneDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1533983_1
queryRedisBusinessOneDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819391_1
queryRedisBusinessOneDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1533984_1
queryRedisBusinessOneDataReq.setRedisParamSortType(reqDto.getRedisParamSortType());//SimpleFieldAssign//sourceId:1846404_1
queryRedisBusinessOneDataReq.setRefCustomField1(reqDto.getRefCustomField1());//SimpleFieldAssign//sourceId:1533985_1
queryRedisBusinessOneDataReq.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1536787_1
queryRedisBusinessOneDataReq.setRefCustomField2(reqDto.getRefCustomField2());//SimpleFieldAssign//sourceId:1533986_1
queryRedisBusinessOneDataReq.setRefCustomFieldValue2(reqDto.getRefCustomFieldValue2());//SimpleFieldAssign//sourceId:1536788_1
queryRedisBusinessOneDataReq.setRefCustomField3(reqDto.getRefCustomField3());//SimpleFieldAssign//sourceId:1533987_1
queryRedisBusinessOneDataReq.setRefCustomFieldValue3(reqDto.getRefCustomFieldValue3());//SimpleFieldAssign//sourceId:1536789_1
queryRedisBusinessOneDataReq.setRefCustomField4(reqDto.getRefCustomField4());//SimpleFieldAssign//sourceId:1533988_1
queryRedisBusinessOneDataReq.setRefCustomFieldValue4(reqDto.getRefCustomFieldValue4());//SimpleFieldAssign//sourceId:1536790_1
queryRedisBusinessOneDataReq.setRefCustomField5(reqDto.getRefCustomField5());//SimpleFieldAssign//sourceId:1533989_1
queryRedisBusinessOneDataReq.setRefCustomFieldValue5(reqDto.getRefCustomFieldValue5());//SimpleFieldAssign//sourceId:1536791_1
queryRedisBusinessOneDataReq.setRefCustomField6(reqDto.getRefCustomField6());//SimpleFieldAssign//sourceId:1533990_1
queryRedisBusinessOneDataReq.setRefCustomFieldValue6(reqDto.getRefCustomFieldValue6());//SimpleFieldAssign//sourceId:1536792_1
queryRedisBusinessOneDataReq.setRefCustomField7(reqDto.getRefCustomField7());//SimpleFieldAssign//sourceId:1533991_1
queryRedisBusinessOneDataReq.setRefCustomFieldValue7(reqDto.getRefCustomFieldValue7());//SimpleFieldAssign//sourceId:1536793_1
queryRedisBusinessOneDataReq.setRefCustomField8(reqDto.getRefCustomField8());//SimpleFieldAssign//sourceId:1533992_1
queryRedisBusinessOneDataReq.setRefCustomFieldValue8(reqDto.getRefCustomFieldValue8());//SimpleFieldAssign//sourceId:1536794_1
    }
if(reqDto!= null&&  reqDto.getRedisBusinessDataResList() !=null&& !CollectionUtil.isEmpty(reqDto.getRedisBusinessDataResList())){
      queryRedisBusinessOneDataReq.setRedisBusinessDataResList(reqDto.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1533993_1
    }

    /*M2-查询入参redis业务数据对象详情（特殊方法）[8474]   */
    Assert.isNull(queryRedisBusinessOneDataReq.getBusinessDataObject(),"D2-查询入参redis业务数据对象详情(公共)-M2-查询入参redis业务数据对象详情（特殊方法）-业务数据对象不能为空",false);
Assert.isNull(queryRedisBusinessOneDataReq.getRedisDataObjectCatalogue(),"D2-查询入参redis业务数据对象详情(公共)-M2-查询入参redis业务数据对象详情（特殊方法）-Redis数据对象目录不能为空",false);
      queryRedisBusinessOneDataRes = nbInterfaceMode.queryRefRedisBusinessDataDetail(queryRedisBusinessOneDataReq);


      queryRedisBusinessOneDataRes_1 = queryRedisBusinessOneDataRes;

QueryRefRedisBusinessDataDetailComRespDto retData = new QueryRefRedisBusinessDataDetailComRespDto();
  if(queryRedisBusinessOneDataRes_1!=null){
      retData.setCustomField1(queryRedisBusinessOneDataRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1534139_1
retData.setCustomField2(queryRedisBusinessOneDataRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1534140_1
retData.setCustomField3(queryRedisBusinessOneDataRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1534141_1
retData.setCustomField4(queryRedisBusinessOneDataRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1534142_1
retData.setCustomField5(queryRedisBusinessOneDataRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1534143_1
retData.setCustomField6(queryRedisBusinessOneDataRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1534144_1
retData.setCustomField7(queryRedisBusinessOneDataRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1534145_1
retData.setCustomField8(queryRedisBusinessOneDataRes_1.getCustomField8());//SimpleFieldAssign//sourceId:1534146_1
retData.setCustomField9(queryRedisBusinessOneDataRes_1.getCustomField9());//SimpleFieldAssign//sourceId:1534147_1
retData.setCustomField10(queryRedisBusinessOneDataRes_1.getCustomField10());//SimpleFieldAssign//sourceId:1534148_1
retData.setCustomField11(queryRedisBusinessOneDataRes_1.getCustomField11());//SimpleFieldAssign//sourceId:1534149_1
retData.setCustomField12(queryRedisBusinessOneDataRes_1.getCustomField12());//SimpleFieldAssign//sourceId:1534150_1
retData.setCustomField13(queryRedisBusinessOneDataRes_1.getCustomField13());//SimpleFieldAssign//sourceId:1534151_1
retData.setCustomField14(queryRedisBusinessOneDataRes_1.getCustomField14());//SimpleFieldAssign//sourceId:1534152_1
retData.setCustomField15(queryRedisBusinessOneDataRes_1.getCustomField15());//SimpleFieldAssign//sourceId:1534153_1
retData.setCustomField16(queryRedisBusinessOneDataRes_1.getCustomField16());//SimpleFieldAssign//sourceId:1534154_1
retData.setCustomField17(queryRedisBusinessOneDataRes_1.getCustomField17());//SimpleFieldAssign//sourceId:1534155_1
retData.setCustomField18(queryRedisBusinessOneDataRes_1.getCustomField18());//SimpleFieldAssign//sourceId:1534156_1
retData.setCustomField19(queryRedisBusinessOneDataRes_1.getCustomField19());//SimpleFieldAssign//sourceId:1534157_1
retData.setCustomField20(queryRedisBusinessOneDataRes_1.getCustomField20());//SimpleFieldAssign//sourceId:1534158_1
retData.setCustomField21(queryRedisBusinessOneDataRes_1.getCustomField21());//SimpleFieldAssign//sourceId:1534159_1
retData.setCustomField22(queryRedisBusinessOneDataRes_1.getCustomField22());//SimpleFieldAssign//sourceId:1534160_1
retData.setCustomField23(queryRedisBusinessOneDataRes_1.getCustomField23());//SimpleFieldAssign//sourceId:1534161_1
retData.setCustomField24(queryRedisBusinessOneDataRes_1.getCustomField24());//SimpleFieldAssign//sourceId:1534162_1
retData.setCustomField25(queryRedisBusinessOneDataRes_1.getCustomField25());//SimpleFieldAssign//sourceId:1534163_1
retData.setCustomField26(queryRedisBusinessOneDataRes_1.getCustomField26());//SimpleFieldAssign//sourceId:1534164_1
retData.setCustomField27(queryRedisBusinessOneDataRes_1.getCustomField27());//SimpleFieldAssign//sourceId:1534165_1
retData.setCustomField28(queryRedisBusinessOneDataRes_1.getCustomField28());//SimpleFieldAssign//sourceId:1534166_1
retData.setCustomField29(queryRedisBusinessOneDataRes_1.getCustomField29());//SimpleFieldAssign//sourceId:1534167_1
retData.setCustomField30(queryRedisBusinessOneDataRes_1.getCustomField30());//SimpleFieldAssign//sourceId:1534168_1
retData.setCustomField31(queryRedisBusinessOneDataRes_1.getCustomField31());//SimpleFieldAssign//sourceId:1534169_1
retData.setCustomField32(queryRedisBusinessOneDataRes_1.getCustomField32());//SimpleFieldAssign//sourceId:1534170_1
retData.setCustomField33(queryRedisBusinessOneDataRes_1.getCustomField33());//SimpleFieldAssign//sourceId:1534171_1
retData.setCustomField34(queryRedisBusinessOneDataRes_1.getCustomField34());//SimpleFieldAssign//sourceId:1534172_1
retData.setCustomField35(queryRedisBusinessOneDataRes_1.getCustomField35());//SimpleFieldAssign//sourceId:1534173_1
retData.setCustomField36(queryRedisBusinessOneDataRes_1.getCustomField36());//SimpleFieldAssign//sourceId:1534174_1
retData.setCustomField37(queryRedisBusinessOneDataRes_1.getCustomField37());//SimpleFieldAssign//sourceId:1534175_1
retData.setCustomField38(queryRedisBusinessOneDataRes_1.getCustomField38());//SimpleFieldAssign//sourceId:1534176_1
retData.setCustomField39(queryRedisBusinessOneDataRes_1.getCustomField39());//SimpleFieldAssign//sourceId:1534177_1
retData.setCustomField40(queryRedisBusinessOneDataRes_1.getCustomField40());//SimpleFieldAssign//sourceId:1534178_1
retData.setCustomField41(queryRedisBusinessOneDataRes_1.getCustomField41());//SimpleFieldAssign//sourceId:1534179_1
retData.setCustomField42(queryRedisBusinessOneDataRes_1.getCustomField42());//SimpleFieldAssign//sourceId:1534180_1
retData.setCustomField43(queryRedisBusinessOneDataRes_1.getCustomField43());//SimpleFieldAssign//sourceId:1534181_1
retData.setCustomField44(queryRedisBusinessOneDataRes_1.getCustomField44());//SimpleFieldAssign//sourceId:1534182_1
retData.setCustomField45(queryRedisBusinessOneDataRes_1.getCustomField45());//SimpleFieldAssign//sourceId:1534183_1
retData.setCustomField46(queryRedisBusinessOneDataRes_1.getCustomField46());//SimpleFieldAssign//sourceId:1534184_1
retData.setCustomField47(queryRedisBusinessOneDataRes_1.getCustomField47());//SimpleFieldAssign//sourceId:1534185_1
retData.setCustomField48(queryRedisBusinessOneDataRes_1.getCustomField48());//SimpleFieldAssign//sourceId:1534186_1
retData.setCustomField49(queryRedisBusinessOneDataRes_1.getCustomField49());//SimpleFieldAssign//sourceId:1534187_1
retData.setCustomField50(queryRedisBusinessOneDataRes_1.getCustomField50());//SimpleFieldAssign//sourceId:1534188_1
retData.setCustomField51(queryRedisBusinessOneDataRes_1.getCustomField51());//SimpleFieldAssign//sourceId:1840390_1
retData.setCustomField52(queryRedisBusinessOneDataRes_1.getCustomField52());//SimpleFieldAssign//sourceId:1840391_1
retData.setCustomField53(queryRedisBusinessOneDataRes_1.getCustomField53());//SimpleFieldAssign//sourceId:1840392_1
retData.setCustomField54(queryRedisBusinessOneDataRes_1.getCustomField54());//SimpleFieldAssign//sourceId:1840393_1
retData.setCustomField55(queryRedisBusinessOneDataRes_1.getCustomField55());//SimpleFieldAssign//sourceId:1840394_1
retData.setCustomField56(queryRedisBusinessOneDataRes_1.getCustomField56());//SimpleFieldAssign//sourceId:1840395_1
    }




return retData;
  }
/**
   * D2新增内存业务数据(公共)[8641]
   * gen by moon at 3/15/2024, 8:49:55 PM
   */
  @Trace(operationName = "D2新增内存业务数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddMemoryBusinessDataComRespDto addMemoryBusinessDataCom(AddMemoryBusinessDataComReqDto reqDto){


      //步骤0: M2新增内存业务数据（特殊方法） - addMemoryBusinessData
     //ModelCode: addMemoryBusinessData
        AddMemoryBusinessDataRespDto addMemoryBusinessDataRes = null;
    AddMemoryBusinessDataReqDto addMemoryBusinessDataReq=new AddMemoryBusinessDataReqDto();
  if(reqDto!=null){
      addMemoryBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1610116_1
addMemoryBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1610118_1
addMemoryBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1610117_1
    }
if(reqDto!= null&&  reqDto.getMemoryBusinessDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getMemoryBusinessDataList())){
      addMemoryBusinessDataReq.setMemoryBusinessDataList(reqDto.getMemoryBusinessDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1610119_1
    }

    /*M2新增内存业务数据（特殊方法）[8639]   */
    Assert.isNull(addMemoryBusinessDataReq.getDataObjectBatchCode(),"D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-数据对象批次标识不能为空",false);
Assert.isNull(addMemoryBusinessDataReq.getBusinessDataObject(),"D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-业务数据对象不能为空",false);
Assert.isNull(addMemoryBusinessDataReq.getIsDataList(),"D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-是否是数据集对象不能为空",false);
      addMemoryBusinessDataRes = nbInterfaceMode.addMemoryBusinessData(addMemoryBusinessDataReq);




AddMemoryBusinessDataComRespDto retData = new AddMemoryBusinessDataComRespDto();





return retData;
  }
///**
//   * D2查询内存业务数据详情(公共)[8642]
//   * gen by moon at 3/15/2024, 8:50:14 PM
//   */
//  @Trace(operationName = "D2查询内存业务数据详情(公共)")
//  @Tags({@Tag(key = "参数",value = "arg[0]"),
//            @Tag(key = "返回值",value = "returnedObj")})
//  @Transactional(rollbackFor=Exception.class)
//  @Override
//  public QueryMemoryBusinessDataDetailComRespDto queryMemoryBusinessDataDetailCom(QueryMemoryBusinessDataDetailComReqDto reqDto){
//
//
//      QueryMemoryBusinessDataDetailRespDto queryMemoryBusinessDataRes_1 =null;
////步骤0: M2查询内存业务数据详情（特殊方法） - queryMemoryBusinessDataDetail
//     //ModelCode: queryMemoryBusinessData
//        QueryMemoryBusinessDataDetailRespDto queryMemoryBusinessDataRes = null;
//    QueryMemoryBusinessDataDetailReqDto queryMemoryBusinessDataReq=new QueryMemoryBusinessDataDetailReqDto();
//  if(reqDto!=null){
//      queryMemoryBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1610124_1
//queryMemoryBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1610125_1
//queryMemoryBusinessDataReq.setMemoryBusinessResDataList(reqDto.getMemoryBusinessResDataList());//list-field-assign//sourceId:1610126_1
//    }
//
//    /*M2查询内存业务数据详情（特殊方法）[8640]   */
//    Assert.isNull(queryMemoryBusinessDataReq.getDataObjectBatchCode(),"D2查询内存业务数据详情(公共)-M2查询内存业务数据详情（特殊方法）-数据对象批次标识不能为空",false);
//Assert.isNull(queryMemoryBusinessDataReq.getBusinessDataObject(),"D2查询内存业务数据详情(公共)-M2查询内存业务数据详情（特殊方法）-业务数据对象不能为空",false);
//      queryMemoryBusinessDataRes = nbInterfaceMode.queryMemoryBusinessDataDetail(queryMemoryBusinessDataReq);
//
//
//      queryMemoryBusinessDataRes_1 = queryMemoryBusinessDataRes;
//
//QueryMemoryBusinessDataDetailComRespDto retData = new QueryMemoryBusinessDataDetailComRespDto();
//  if(queryMemoryBusinessDataRes_1!=null){
//      retData.setCustomField1(queryMemoryBusinessDataRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1610180_1
//retData.setCustomField2(queryMemoryBusinessDataRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1610181_1
//retData.setCustomField3(queryMemoryBusinessDataRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1610182_1
//retData.setCustomField4(queryMemoryBusinessDataRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1610183_1
//retData.setCustomField5(queryMemoryBusinessDataRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1610184_1
//retData.setCustomField6(queryMemoryBusinessDataRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1610185_1
//retData.setCustomField7(queryMemoryBusinessDataRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1610186_1
//retData.setCustomField8(queryMemoryBusinessDataRes_1.getCustomField8());//SimpleFieldAssign//sourceId:1610187_1
//retData.setCustomField9(queryMemoryBusinessDataRes_1.getCustomField9());//SimpleFieldAssign//sourceId:1610188_1
//retData.setCustomField10(queryMemoryBusinessDataRes_1.getCustomField10());//SimpleFieldAssign//sourceId:1610189_1
//retData.setCustomField11(queryMemoryBusinessDataRes_1.getCustomField11());//SimpleFieldAssign//sourceId:1610190_1
//retData.setCustomField12(queryMemoryBusinessDataRes_1.getCustomField12());//SimpleFieldAssign//sourceId:1610191_1
//retData.setCustomField13(queryMemoryBusinessDataRes_1.getCustomField13());//SimpleFieldAssign//sourceId:1610192_1
//retData.setCustomField14(queryMemoryBusinessDataRes_1.getCustomField14());//SimpleFieldAssign//sourceId:1610193_1
//retData.setCustomField15(queryMemoryBusinessDataRes_1.getCustomField15());//SimpleFieldAssign//sourceId:1610194_1
//retData.setCustomField16(queryMemoryBusinessDataRes_1.getCustomField16());//SimpleFieldAssign//sourceId:1610195_1
//retData.setCustomField17(queryMemoryBusinessDataRes_1.getCustomField17());//SimpleFieldAssign//sourceId:1610196_1
//retData.setCustomField18(queryMemoryBusinessDataRes_1.getCustomField18());//SimpleFieldAssign//sourceId:1610197_1
//retData.setCustomField19(queryMemoryBusinessDataRes_1.getCustomField19());//SimpleFieldAssign//sourceId:1610198_1
//retData.setCustomField20(queryMemoryBusinessDataRes_1.getCustomField20());//SimpleFieldAssign//sourceId:1610199_1
//retData.setCustomField21(queryMemoryBusinessDataRes_1.getCustomField21());//SimpleFieldAssign//sourceId:1610200_1
//retData.setCustomField22(queryMemoryBusinessDataRes_1.getCustomField22());//SimpleFieldAssign//sourceId:1610201_1
//retData.setCustomField23(queryMemoryBusinessDataRes_1.getCustomField23());//SimpleFieldAssign//sourceId:1610202_1
//retData.setCustomField24(queryMemoryBusinessDataRes_1.getCustomField24());//SimpleFieldAssign//sourceId:1610203_1
//retData.setCustomField25(queryMemoryBusinessDataRes_1.getCustomField25());//SimpleFieldAssign//sourceId:1610204_1
//retData.setCustomField26(queryMemoryBusinessDataRes_1.getCustomField26());//SimpleFieldAssign//sourceId:1610205_1
//retData.setCustomField27(queryMemoryBusinessDataRes_1.getCustomField27());//SimpleFieldAssign//sourceId:1610206_1
//retData.setCustomField28(queryMemoryBusinessDataRes_1.getCustomField28());//SimpleFieldAssign//sourceId:1610207_1
//retData.setCustomField29(queryMemoryBusinessDataRes_1.getCustomField29());//SimpleFieldAssign//sourceId:1610208_1
//retData.setCustomField30(queryMemoryBusinessDataRes_1.getCustomField30());//SimpleFieldAssign//sourceId:1610209_1
//retData.setCustomField31(queryMemoryBusinessDataRes_1.getCustomField31());//SimpleFieldAssign//sourceId:1610210_1
//retData.setCustomField32(queryMemoryBusinessDataRes_1.getCustomField32());//SimpleFieldAssign//sourceId:1610211_1
//retData.setCustomField33(queryMemoryBusinessDataRes_1.getCustomField33());//SimpleFieldAssign//sourceId:1610212_1
//retData.setCustomField34(queryMemoryBusinessDataRes_1.getCustomField34());//SimpleFieldAssign//sourceId:1610213_1
//retData.setCustomField35(queryMemoryBusinessDataRes_1.getCustomField35());//SimpleFieldAssign//sourceId:1610214_1
//retData.setCustomField36(queryMemoryBusinessDataRes_1.getCustomField36());//SimpleFieldAssign//sourceId:1610215_1
//retData.setCustomField37(queryMemoryBusinessDataRes_1.getCustomField37());//SimpleFieldAssign//sourceId:1610216_1
//retData.setCustomField38(queryMemoryBusinessDataRes_1.getCustomField38());//SimpleFieldAssign//sourceId:1610217_1
//retData.setCustomField39(queryMemoryBusinessDataRes_1.getCustomField39());//SimpleFieldAssign//sourceId:1610218_1
//retData.setCustomField40(queryMemoryBusinessDataRes_1.getCustomField40());//SimpleFieldAssign//sourceId:1610219_1
//retData.setCustomField41(queryMemoryBusinessDataRes_1.getCustomField41());//SimpleFieldAssign//sourceId:1610220_1
//retData.setCustomField42(queryMemoryBusinessDataRes_1.getCustomField42());//SimpleFieldAssign//sourceId:1610221_1
//retData.setCustomField43(queryMemoryBusinessDataRes_1.getCustomField43());//SimpleFieldAssign//sourceId:1610222_1
//retData.setCustomField44(queryMemoryBusinessDataRes_1.getCustomField44());//SimpleFieldAssign//sourceId:1610223_1
//retData.setCustomField45(queryMemoryBusinessDataRes_1.getCustomField45());//SimpleFieldAssign//sourceId:1610224_1
//retData.setCustomField46(queryMemoryBusinessDataRes_1.getCustomField46());//SimpleFieldAssign//sourceId:1610225_1
//retData.setCustomField47(queryMemoryBusinessDataRes_1.getCustomField47());//SimpleFieldAssign//sourceId:1610226_1
//retData.setCustomField48(queryMemoryBusinessDataRes_1.getCustomField48());//SimpleFieldAssign//sourceId:1610227_1
//retData.setCustomField49(queryMemoryBusinessDataRes_1.getCustomField49());//SimpleFieldAssign//sourceId:1610228_1
//retData.setCustomField50(queryMemoryBusinessDataRes_1.getCustomField50());//SimpleFieldAssign//sourceId:1610229_1
//    }
//
//
//
//
//return retData;
//  }
/**
   * D2执行数据集聚合(公共)[8667]
   * gen by moon at 3/16/2024, 11:18:41 PM
   */
  @Trace(operationName = "D2执行数据集聚合(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDatasetAggregationComRespDto implementDatasetAggregationCom(ImplementDatasetAggregationComReqDto reqDto){


      ImplementDatasetAggregationRespDto collectionsAggregationRes_1 =null;
//步骤0: M2执行数据集聚合 - implementDatasetAggregation
     //ModelCode: collectionsAggregation
        ImplementDatasetAggregationRespDto collectionsAggregationRes = null;
    ImplementDatasetAggregationReqDto collectionsAggregationReq=new ImplementDatasetAggregationReqDto();
  if(reqDto!= null&&  reqDto.getDataSetsListOne() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())){
      collectionsAggregationReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1613823_1
    }
if(reqDto!= null&&  reqDto.getDataSetsListTwo() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())){
      collectionsAggregationReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1613824_1
    }

    /*M2执行数据集聚合[8668]  入参多个数据集，按照聚合标识得到一个新的数据集 */

      collectionsAggregationRes = nbInterfaceMode.implementDatasetAggregation(collectionsAggregationReq);


      collectionsAggregationRes_1 = collectionsAggregationRes;

ImplementDatasetAggregationComRespDto retData = new ImplementDatasetAggregationComRespDto();
  if(collectionsAggregationRes_1!=null){
      retData.setCollectionsAggregationList(collectionsAggregationRes_1.getCollectionsAggregationList().stream().map(item -> BeanUtil.toBean(item, CollectionsAggregationDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1613833_1
    }




return retData;
  }
/**
   * D2执行本级过程得分权重动态分配(公共)[8687]
   * gen by moon at 5/13/2024, 12:07:25 AM
   */
  @Trace(operationName = "D2执行本级过程得分权重动态分配(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDataRedistributionComRespDto implementDataRedistributionCom(ImplementDataRedistributionComReqDto reqDto){


      ImplementDataRedistributionRespDto dataRedistributionRes_1 =null;
//步骤0: M2执行数据重分配（特殊方法） - implementDataRedistribution
     //ModelCode: dataRedistribution
        ImplementDataRedistributionRespDto dataRedistributionRes = null;
    ImplementDataRedistributionReqDto dataRedistributionReq=new ImplementDataRedistributionReqDto();
  if(reqDto!=null){
dataRedistributionReq.setReportScoreSubAndObjWeightChg(reqDto.getReportScoreSubAndObjWeightChg());//SimpleFieldAssign//sourceId:1617416_1
dataRedistributionReq.setProcessReportScoreProMidWeightChg(reqDto.getProcessReportScoreProMidWeightChg());//SimpleFieldAssign//sourceId:1617377_1
dataRedistributionReq.setProcessReportScoreMidWeightChg(reqDto.getProcessReportScoreMidWeightChg());//SimpleFieldAssign//sourceId:1617378_1
dataRedistributionReq.setProcessReportScoreAvgWeightChg(reqDto.getProcessReportScoreAvgWeightChg());//SimpleFieldAssign//sourceId:1617380_1
dataRedistributionReq.setWeightTotal(reqDto.getWeightTotal());//SimpleFieldAssign//sourceId:1792052_1
    }

    /*M2执行数据重分配（特殊方法）[8686]  用于过程汇报得分权重组成部分按照比例重新分配 */
Assert.isNull(dataRedistributionReq.getReportScoreSubAndObjWeightChg(),"D2执行本级过程得分权重动态分配(公共)-M2执行数据重分配（特殊方法）-本级过程得分_主客观得分权重变化不能为空",false);
Assert.isNull(dataRedistributionReq.getProcessReportScoreProMidWeightChg(),"D2执行本级过程得分权重动态分配(公共)-M2执行数据重分配（特殊方法）-本级过程得分_过程中期得分权重变化不能为空",false);
Assert.isNull(dataRedistributionReq.getProcessReportScoreMidWeightChg(),"D2执行本级过程得分权重动态分配(公共)-M2执行数据重分配（特殊方法）-本级过程得分_中期得分权重变化不能为空",false);
Assert.isNull(dataRedistributionReq.getProcessReportScoreAvgWeightChg(),"D2执行本级过程得分权重动态分配(公共)-M2执行数据重分配（特殊方法）-本级过程得分_最近平均分权重变化不能为空",false);
      dataRedistributionRes = nbInterfaceMode.implementDataRedistribution(dataRedistributionReq);


      dataRedistributionRes_1 = dataRedistributionRes;

ImplementDataRedistributionComRespDto retData = new ImplementDataRedistributionComRespDto();
  if(dataRedistributionRes_1!=null){
      retData.setReportScoreSubAndObjWeight(dataRedistributionRes_1.getReportScoreSubAndObjWeight());//SimpleFieldAssign//sourceId:1617419_1
retData.setProcessReportScoreProMidWeight(dataRedistributionRes_1.getProcessReportScoreProMidWeight());//SimpleFieldAssign//sourceId:1617389_1
retData.setProcessReportScoreMidWeight(dataRedistributionRes_1.getProcessReportScoreMidWeight());//SimpleFieldAssign//sourceId:1617390_1
retData.setProcessReportScoreAvgWeight(dataRedistributionRes_1.getProcessReportScoreAvgWeight());//SimpleFieldAssign//sourceId:1617392_1
    }




return retData;
  }
/**
   * D2执行接收转换数值(公共)[8688]
   * gen by moon at 3/22/2024, 2:08:42 AM
   */
  @Trace(operationName = "D2执行接收转换数值(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementReceiveConversionResultValueComRespDto implementReceiveConversionResultValueCom(ImplementReceiveConversionResultValueComReqDto reqDto){


      ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes_3 =null;
//virtualUsage M2接收字段  63479
      //ModelCode: receptionService
        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes = null;
    ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq=new ImplementSmartSessionReceiveFieldInputReqDto();
  receptionServiceReq.setComFloatField1(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:1618210_1_63479
if(reqDto!=null){
      receptionServiceReq.setComFloatField(reqDto.getComFloatField());//SimpleFieldAssign//sourceId:1618113_1_63479
receptionServiceReq.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1618795_1_63479
    }

    /*M2接收字段[8109]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComFloatField1(),"D2执行接收转换数值(公共)-M2接收字段-通用数值字段1（小数型）不能为空",false);
      receptionServiceRes = nbInterfaceMode.implementSmartSessionReceiveFieldInput(receptionServiceReq);



if((reqDto!= null&& reqDto.getComFloatField() != null )) {
        //if(D2执行接收转换数值(公共).通用数值字段（小数型） 值不等于空 )  63475

//ModelCode: receptionService
        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes_2 = null;
    ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq_1=new ImplementSmartSessionReceiveFieldInputReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setComFloatField(reqDto.getComFloatField());//SimpleFieldAssign//sourceId:1618203_1_63476
receptionServiceReq_1.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1618878_1_63476
    }

    /*M2接收字段出参[8109]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getComFloatField(),"D2执行接收转换数值(公共)-M2接收字段出参-通用数值字段（小数型）不能为空",false);
Assert.isNull(receptionServiceReq_1.getWeightValue(),"D2执行接收转换数值(公共)-M2接收字段出参-权重不能为空",false);
      receptionServiceRes_2 = nbInterfaceMode.implementSmartSessionReceiveFieldInput(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&& reqDto.getComFloatField() == null )){
       //elseif(D2执行接收转换数值(公共).通用数值字段（小数型） 值等于空 )  63477

//ModelCode: receptionService
        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes_4 = null;
    ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq_2=new ImplementSmartSessionReceiveFieldInputReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setComFloatField(receptionServiceRes.getComFloatField1());//SimpleFieldAssign//sourceId:1618203_1_63478
    }
if(reqDto!=null){
      receptionServiceReq_2.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1618878_1_63478
    }

    /*M2接收字段出参[8109]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getComFloatField(),"D2执行接收转换数值(公共)-M2接收字段出参-通用数值字段（小数型）不能为空",false);
Assert.isNull(receptionServiceReq_2.getWeightValue(),"D2执行接收转换数值(公共)-M2接收字段出参-权重不能为空",false);
      receptionServiceRes_4 = nbInterfaceMode.implementSmartSessionReceiveFieldInput(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
ImplementReceiveConversionResultValueComRespDto retData = new ImplementReceiveConversionResultValueComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setComFloatField(receptionServiceRes_3.getComFloatField());//SimpleFieldAssign//sourceId:1618213_1
retData.setWeightValue(receptionServiceRes_3.getWeightValue());//SimpleFieldAssign//sourceId:1618880_1
    }




return retData;
  }
/**
   * D2执行开始与结束时间格式转换(公共)[8780]
   * gen by moon at 3/28/2024, 11:38:35 PM
   */
  @Trace(operationName = "D2执行开始与结束时间格式转换(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementStartAndEndTimeFormatComRespDto implementStartAndEndTimeFormatCom(ImplementStartAndEndTimeFormatComReqDto reqDto){


      ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes_1 =null;
//virtualUsage D2执行时间格式化(公共)  65138
      ImplementDateFormatComRespDto implementDateFormatComRespDto = null;
    ImplementDateFormatComReqDto implementDateFormatComReqDto=new ImplementDateFormatComReqDto();
  if(reqDto!=null){
      implementDateFormatComReqDto.setComTimeField(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1658346_1_65138
implementDateFormatComReqDto.setTimeFormatMode(reqDto.getTimeFormatMode());//SimpleFieldAssign//sourceId:1658347_1_65138
    }

    /*D2执行时间格式化(公共)[8203]   */
    Assert.isNull(implementDateFormatComReqDto.getComTimeField(),"D2执行开始与结束时间格式转换(公共)-D2执行时间格式化(公共)-通用时间字段不能为空",false);
Assert.isNull(implementDateFormatComReqDto.getTimeFormatMode(),"D2执行开始与结束时间格式转换(公共)-D2执行时间格式化(公共)-时间格式模式不能为空",false);
      implementDateFormatComRespDto = implementDateFormatCom(implementDateFormatComReqDto)/*vcase invoke 同服务,同domain*/;



//virtualUsage D2执行时间格式化(公共)  65139
      ImplementDateFormatComRespDto implementDateFormatComRespDto_2 = null;
    ImplementDateFormatComReqDto implementDateFormatComReqDto_1=new ImplementDateFormatComReqDto();
  if(reqDto!=null){
      implementDateFormatComReqDto_1.setComTimeField(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1658346_1_65139
implementDateFormatComReqDto_1.setTimeFormatMode(reqDto.getTimeFormatMode());//SimpleFieldAssign//sourceId:1658347_1_65139
    }

    /*D2执行时间格式化(公共)[8203]   */
    Assert.isNull(implementDateFormatComReqDto_1.getComTimeField(),"D2执行开始与结束时间格式转换(公共)-D2执行时间格式化(公共)-通用时间字段不能为空",false);
Assert.isNull(implementDateFormatComReqDto_1.getTimeFormatMode(),"D2执行开始与结束时间格式转换(公共)-D2执行时间格式化(公共)-时间格式模式不能为空",false);
      implementDateFormatComRespDto_2 = implementDateFormatCom(implementDateFormatComReqDto_1)/*vcase invoke 同服务,同domain*/;



//virtualUsage M2接收开始与结束时间转换格式出参  65140
      //ModelCode: receptionService
        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes = null;
    if(implementDateFormatComRespDto !=null&&implementDateFormatComRespDto_2 !=null){
          ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq=new ImplementSmartSessionReceiveFieldInputReqDto();
  if(implementDateFormatComRespDto!=null){
      receptionServiceReq.setCustomField1(implementDateFormatComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1658640_1_65140
    }
if(implementDateFormatComRespDto_2!=null){
      receptionServiceReq.setCustomField2(implementDateFormatComRespDto_2.getComTxtField());//SimpleFieldAssign//sourceId:1658641_1_65140
    }

    /*M2接收开始与结束时间转换格式出参[8109]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D2执行开始与结束时间格式转换(公共)-M2接收开始与结束时间转换格式出参-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D2执行开始与结束时间格式转换(公共)-M2接收开始与结束时间转换格式出参-自定义字段2不能为空",false);
      receptionServiceRes = nbInterfaceMode.implementSmartSessionReceiveFieldInput(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
ImplementStartAndEndTimeFormatComRespDto retData = new ImplementStartAndEndTimeFormatComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setCycleStartTimeName(receptionServiceRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1658644_1
retData.setCycleEndTimeName(receptionServiceRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1658647_1
    }




return retData;
  }
/**
   * D2生成数据对象批次标识(公共)[9404]
   * gen by moon at 5/26/2024, 10:43:48 PM
   */
  @Trace(operationName = "D2生成数据对象批次标识(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public GenerateDataObjectBatchCodeComRespDto generateDataObjectBatchCodeCom(GenerateDataObjectBatchCodeComReqDto reqDto){


      ImplementTenReceivingFieldRespDto receptionServiceRes_1 =null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
      // TODO: 2024/5/22
    receptionServiceReq.setDataObjectBatchCode("EVDB");//CUSTOM_CONVENTION//sourceId:1736979_1

    /*M2生成数据对象批次标识[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDataObjectBatchCode(),"D2生成数据对象批次标识(公共)-M2生成数据对象批次标识-数据对象批次标识不能为空",false);
      receptionServiceRes = nbInterfaceMode.implementTenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;

GenerateDataObjectBatchCodeComRespDto retData = new GenerateDataObjectBatchCodeComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setDataObjectBatchCode(receptionServiceRes_1.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1736980_1
    }




return retData;
  }
/**
   * D2修改redis业务数据对象(公共)[9405]
   * gen by moon at 6/8/2024, 8:04:26 PM
   */
  @Trace(operationName = "D2修改redis业务数据对象(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UpdateRedisBusinessDataComRespDto updateRedisBusinessDataCom(UpdateRedisBusinessDataComReqDto reqDto){


      //步骤0: M2修改redis业务数据对象 - updateRedisBusinessData
     //ModelCode: updateRedisBusinessData
        UpdateRedisBusinessDataRespDto updateRedisBusinessDataRes = null;
    UpdateRedisBusinessDataReqDto updateRedisBusinessDataReq=new UpdateRedisBusinessDataReqDto();
  if(reqDto!=null){
      updateRedisBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1737028_1
updateRedisBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1737029_1
updateRedisBusinessDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819396_1
updateRedisBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1737030_1
updateRedisBusinessDataReq.setRefCustomField1(reqDto.getRefCustomField1());//SimpleFieldAssign//sourceId:1830674_1
updateRedisBusinessDataReq.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1830675_1
updateRedisBusinessDataReq.setRefCustomField2(reqDto.getRefCustomField2());//SimpleFieldAssign//sourceId:1830676_1
updateRedisBusinessDataReq.setRefCustomFieldValue2(reqDto.getRefCustomFieldValue2());//SimpleFieldAssign//sourceId:1830677_1
updateRedisBusinessDataReq.setRefCustomField3(reqDto.getRefCustomField3());//SimpleFieldAssign//sourceId:1830678_1
updateRedisBusinessDataReq.setRefCustomFieldValue3(reqDto.getRefCustomFieldValue3());//SimpleFieldAssign//sourceId:1830679_1
updateRedisBusinessDataReq.setRefCustomField4(reqDto.getRefCustomField4());//SimpleFieldAssign//sourceId:1830680_1
updateRedisBusinessDataReq.setRefCustomFieldValue4(reqDto.getRefCustomFieldValue4());//SimpleFieldAssign//sourceId:1830681_1
updateRedisBusinessDataReq.setRefCustomField5(reqDto.getRefCustomField5());//SimpleFieldAssign//sourceId:1830682_1
updateRedisBusinessDataReq.setRefCustomFieldValue5(reqDto.getRefCustomFieldValue5());//SimpleFieldAssign//sourceId:1830683_1
updateRedisBusinessDataReq.setRefCustomField6(reqDto.getRefCustomField6());//SimpleFieldAssign//sourceId:1830684_1
updateRedisBusinessDataReq.setRefCustomFieldValue6(reqDto.getRefCustomFieldValue6());//SimpleFieldAssign//sourceId:1830685_1
updateRedisBusinessDataReq.setRefCustomField7(reqDto.getRefCustomField7());//SimpleFieldAssign//sourceId:1857067_1
updateRedisBusinessDataReq.setRefCustomFieldValue7(reqDto.getRefCustomFieldValue7());//SimpleFieldAssign//sourceId:1857068_1
updateRedisBusinessDataReq.setRefCustomField8(reqDto.getRefCustomField8());//SimpleFieldAssign//sourceId:1857069_1
updateRedisBusinessDataReq.setRefCustomFieldValue8(reqDto.getRefCustomFieldValue8());//SimpleFieldAssign//sourceId:1857070_1
    }
if(reqDto!= null&&  reqDto.getFieldDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getFieldDataList())){
      updateRedisBusinessDataReq.setFieldDataList(reqDto.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1737027_1
    }

    /*M2修改redis业务数据对象[9406]   */
Assert.isNull(updateRedisBusinessDataReq.getBusinessDataObject(),"D2修改redis业务数据对象(公共)-M2修改redis业务数据对象-业务数据对象不能为空",false);
Assert.isNull(updateRedisBusinessDataReq.getRedisDataObjectCatalogue(),"D2修改redis业务数据对象(公共)-M2修改redis业务数据对象-Redis数据对象目录不能为空",false);
Assert.isNull(updateRedisBusinessDataReq.getIsDataList(),"D2修改redis业务数据对象(公共)-M2修改redis业务数据对象-是否是数据集对象不能为空",false);
      updateRedisBusinessDataRes = nbInterfaceMode.updateRedisBusinessData(updateRedisBusinessDataReq);




UpdateRedisBusinessDataComRespDto retData = new UpdateRedisBusinessDataComRespDto();





return retData;
  }
/**
   * D2执行数据集取最新一条(公共)[9408]
   * gen by moon at 4/18/2024, 11:08:48 PM
   */
  @Trace(operationName = "D2执行数据集取最新一条(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDatasSetFetchNewLatestComRespDto implementDatasSetFetchNewLatestCom(ImplementDatasSetFetchNewLatestComReqDto reqDto){


      ImplementDatasSetFetchNewLatestRespDto newestOfMultipleNumRes_1 =null;
//步骤0: M2执行数据集取最新一条（特殊方法） - implementDatasSetFetchNewLatest
     //ModelCode: newestOfMultipleNum
        ImplementDatasSetFetchNewLatestRespDto newestOfMultipleNumRes = null;
    ImplementDatasSetFetchNewLatestReqDto newestOfMultipleNumReq=new ImplementDatasSetFetchNewLatestReqDto();
  if(reqDto!= null&&  reqDto.getBusinessDataSetList() !=null&& !CollectionUtil.isEmpty(reqDto.getBusinessDataSetList())){
      newestOfMultipleNumReq.setBusinessDataSetList(reqDto.getBusinessDataSetList().stream().map(item -> BeanUtil.toBean(item, BusinessDataSetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1737363_1
    }

    /*M2执行数据集取最新一条（特殊方法）[9409]  用于数据集中最新一条数据算法 */

      newestOfMultipleNumRes = nbInterfaceMode.implementDatasSetFetchNewLatest(newestOfMultipleNumReq);


      newestOfMultipleNumRes_1 = newestOfMultipleNumRes;

ImplementDatasSetFetchNewLatestComRespDto retData = new ImplementDatasSetFetchNewLatestComRespDto();
  if(newestOfMultipleNumRes_1!=null){
      retData.setCommPrimaryKey(newestOfMultipleNumRes_1.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1737365_1
    }




return retData;
  }
/**
   * D2执行数据集取最后一条(公共)[9408]
   * gen by moon at 4/23/2024, 3:41:05 AM
   */
  @Trace(operationName = "D2执行数据集取最后一条(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDatasSetFetchLastLatestComRespDto implementDatasSetFetchLastLatestCom(ImplementDatasSetFetchLastLatestComReqDto reqDto){


      ImplementDatasSetFetchLastLatestRespDto newestOfMultipleNumRes_1 =null;
//步骤0: M2执行数据集取最后一条（特殊方法） - implementDatasSetFetchLastLatest
     //ModelCode: newestOfMultipleNum
        ImplementDatasSetFetchLastLatestRespDto newestOfMultipleNumRes = null;
    ImplementDatasSetFetchLastLatestReqDto newestOfMultipleNumReq=new ImplementDatasSetFetchLastLatestReqDto();
  if(reqDto!= null&&  reqDto.getBusinessDataSetList() !=null&& !CollectionUtil.isEmpty(reqDto.getBusinessDataSetList())){
      newestOfMultipleNumReq.setBusinessDataSetList(reqDto.getBusinessDataSetList().stream().map(item -> BeanUtil.toBean(item, BusinessDataSetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1737363_1
    }

    /*M2执行数据集取最后一条（特殊方法）[9409]  用于数据集中最新一条数据算法 */

      newestOfMultipleNumRes = nbInterfaceMode.implementDatasSetFetchLastLatest(newestOfMultipleNumReq);


      newestOfMultipleNumRes_1 = newestOfMultipleNumRes;

ImplementDatasSetFetchLastLatestComRespDto retData = new ImplementDatasSetFetchLastLatestComRespDto();
  if(newestOfMultipleNumRes_1!=null){
      retData.setCommPrimaryKey(newestOfMultipleNumRes_1.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1737365_1
    }




return retData;
  }
/**
   * D2两数据集模糊匹配指定字段数据集结果(公共)[9545]
   * gen by moon at 5/11/2024, 11:16:20 PM
   */
  @Trace(operationName = "D2两数据集模糊匹配指定字段数据集结果(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTwoDatasVagueMateAssignDatasResultComRespDto implementTwoDatasVagueMateAssignDatasResultCom(ImplementTwoDatasVagueMateAssignDatasResultComReqDto reqDto){


      ImplementTwoDatasVagueMateAssignDatasResultRespDto aDatasLoopVagueMateAssignBdatasResultRes_1 =null;
//步骤0: M2两数据集模糊匹配指定字段数据集结果（特殊方法） - implementTwoDatasVagueMateAssignDatasResult
     //ModelCode: aDatasLoopVagueMateAssignBdatasResult
        ImplementTwoDatasVagueMateAssignDatasResultRespDto aDatasLoopVagueMateAssignBdatasResultRes = null;
    ImplementTwoDatasVagueMateAssignDatasResultReqDto aDatasLoopVagueMateAssignBdatasResultReq=new ImplementTwoDatasVagueMateAssignDatasResultReqDto();
  if(reqDto!=null){
      aDatasLoopVagueMateAssignBdatasResultReq.setDataSetsListOne(reqDto.getDataSetsListOne());//list-field-assign//sourceId:1790000_1
    }
if(reqDto!= null&&  reqDto.getDataSetsListTwo() !=null&& !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())){
      aDatasLoopVagueMateAssignBdatasResultReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1790001_1
    }

    /*M2两数据集模糊匹配指定字段数据集结果（特殊方法）[9546]  A数据集循环发牌，模糊匹配B数据集指定字段的结果，并出参匹配的结果数据集 */

      aDatasLoopVagueMateAssignBdatasResultRes = nbInterfaceMode.implementTwoDatasVagueMateAssignDatasResult(aDatasLoopVagueMateAssignBdatasResultReq);


      aDatasLoopVagueMateAssignBdatasResultRes_1 = aDatasLoopVagueMateAssignBdatasResultRes;

ImplementTwoDatasVagueMateAssignDatasResultComRespDto retData = new ImplementTwoDatasVagueMateAssignDatasResultComRespDto();
  if(aDatasLoopVagueMateAssignBdatasResultRes_1!=null){
      retData.setComDatasList(aDatasLoopVagueMateAssignBdatasResultRes_1.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1790003_1
    }




return retData;
  }
/**
   * D2文本字段指定格式转数据集(公共)[9549]
   * gen by moon at 5/11/2024, 11:16:39 PM
   */
  @Trace(operationName = "D2文本字段指定格式转数据集(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTextFieldAssignFormatTurnDatasComRespDto implementTextFieldAssignFormatTurnDatasCom(ImplementTextFieldAssignFormatTurnDatasComReqDto reqDto){


      ImplementTextFieldAssignFormatTurnDatasRespDto textFieldAssignFormatTurnDatasRes_1 =null;
//步骤0: M2执行文本字段指定格式转数据集（特殊方法） - implementTextFieldAssignFormatTurnDatas
     //ModelCode: textFieldAssignFormatTurnDatas
        ImplementTextFieldAssignFormatTurnDatasRespDto textFieldAssignFormatTurnDatasRes = null;
    ImplementTextFieldAssignFormatTurnDatasReqDto textFieldAssignFormatTurnDatasReq=new ImplementTextFieldAssignFormatTurnDatasReqDto();
  if(reqDto!=null){
      textFieldAssignFormatTurnDatasReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1790020_1
textFieldAssignFormatTurnDatasReq.setSeparator(reqDto.getSeparator());//SimpleFieldAssign//sourceId:1790021_1
    }

    /*M2执行文本字段指定格式转数据集（特殊方法）[9548]  指定格式分隔符的文本字段值转数据集 */
    Assert.isNull(textFieldAssignFormatTurnDatasReq.getCustomField(),"D2文本字段指定格式转数据集(公共)-M2执行文本字段指定格式转数据集（特殊方法）-自定义字段不能为空",false);
Assert.isNull(textFieldAssignFormatTurnDatasReq.getSeparator(),"D2文本字段指定格式转数据集(公共)-M2执行文本字段指定格式转数据集（特殊方法）-分隔符不能为空",false);
      textFieldAssignFormatTurnDatasRes = nbInterfaceMode.implementTextFieldAssignFormatTurnDatas(textFieldAssignFormatTurnDatasReq);


      textFieldAssignFormatTurnDatasRes_1 = textFieldAssignFormatTurnDatasRes;

ImplementTextFieldAssignFormatTurnDatasComRespDto retData = new ImplementTextFieldAssignFormatTurnDatasComRespDto();
  if(textFieldAssignFormatTurnDatasRes_1!=null){
      retData.setComDatasList(textFieldAssignFormatTurnDatasRes_1.getComDatasList());//list-field-assign//sourceId:1790025_1
    }




return retData;
  }
/**
   * D2输出当前树排序值(公共)[9596]
   * gen by moon at 5/17/2024, 1:45:48 AM
   */
  @Trace(operationName = "D2输出当前树排序值(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainOutPutCurrentTreeOrderNumberComRespDto obtainOutPutCurrentTreeOrderNumberCom(ObtainOutPutCurrentTreeOrderNumberComReqDto reqDto){


      ObtainOutPutCurrentTreeOrderNumberComRespDto outPutCurrentTreeOrderNumberRes_1 =null;
//步骤0: M2输出当前树排序值(公共) - obtainOutPutCurrentTreeOrderNumberCom
     //ModelCode: outPutCurrentTreeOrderNumber
        ObtainOutPutCurrentTreeOrderNumberComRespDto outPutCurrentTreeOrderNumberRes = null;
    ObtainOutPutCurrentTreeOrderNumberComReqDto outPutCurrentTreeOrderNumberReq=new ObtainOutPutCurrentTreeOrderNumberComReqDto();
  if(reqDto!=null){
      outPutCurrentTreeOrderNumberReq.setSuperiorsTreeOrderNumbeir(reqDto.getSuperiorsTreeOrderNumbeir());//SimpleFieldAssign//sourceId:1805616_1
outPutCurrentTreeOrderNumberReq.setOrderNumber(reqDto.getOrderNumber());//SimpleFieldAssign//sourceId:1805617_1
    }

    /*M2输出当前树排序值(公共)[9597] 通过上级树排序与当前排序，分析出当前树排序值。例如：上级树排序值1001，本级排序1，则本级树排序值为10011001 通过上级树排序与当前排序，分析出当前树排序值。例如：上级树排序值1001，本级排序1，则本级树排序值为10011001 */
    Assert.isNull(outPutCurrentTreeOrderNumberReq.getSuperiorsTreeOrderNumbeir(),"D2输出当前树排序值(公共)-M2输出当前树排序值(公共)-上级树排序不能为空",false);
Assert.isNull(outPutCurrentTreeOrderNumberReq.getOrderNumber(),"D2输出当前树排序值(公共)-M2输出当前树排序值(公共)-排序不能为空",false);
      outPutCurrentTreeOrderNumberRes = nbInterfaceMode.obtainOutPutCurrentTreeOrderNumberCom(outPutCurrentTreeOrderNumberReq);


      outPutCurrentTreeOrderNumberRes_1 = outPutCurrentTreeOrderNumberRes;

ObtainOutPutCurrentTreeOrderNumberComRespDto retData = new ObtainOutPutCurrentTreeOrderNumberComRespDto();
  if(outPutCurrentTreeOrderNumberRes_1!=null){
      retData.setTreeOrderNumbeir(outPutCurrentTreeOrderNumberRes_1.getTreeOrderNumbeir());//SimpleFieldAssign//sourceId:1805621_1
    }




return retData;
  }
/**
   * D2执行空间配置推送内容(公共)[9606]
   * gen by moon at 5/18/2024, 7:24:23 PM
   */
  @Trace(operationName = "D2执行空间配置推送内容(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSpaceConfPushMemoryComRespDto implementSpaceConfPushMemoryCom(ImplementSpaceConfPushMemoryComReqDto reqDto){

      //步骤0: M2执行空间配置推送内容（特殊方法） - implementSpaceConfPushMemory
     //ModelCode: publicFieldCache
        ImplementSpaceConfPushMemoryRespDto publicFieldCacheRes = null;
    ImplementSpaceConfPushMemoryReqDto publicFieldCacheReq=new ImplementSpaceConfPushMemoryReqDto();
  if(reqDto!=null){
      publicFieldCacheReq.setFileDisplayRootPath(reqDto.getFileDisplayRootPath());//SimpleFieldAssign//sourceId:1807275_1
    }

    /*M2执行空间配置推送内容（特殊方法）[9605]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
    Assert.isNull(publicFieldCacheReq.getFileDisplayRootPath(),"D2执行空间配置推送内容(公共)-M2执行空间配置推送内容（特殊方法）-文件展示根路径不能为空",false);
      publicFieldCacheRes = nbInterfaceMode.implementSpaceConfPushMemory(publicFieldCacheReq);




ImplementSpaceConfPushMemoryComRespDto retData = new ImplementSpaceConfPushMemoryComRespDto();





return retData;
  }
/**
   * D2执行并发行为主题锁(悬停等待)[9699]
   * gen by moon at 6/2/2024, 10:24:41 PM
   */
  @Trace(operationName = "D2执行并发行为主题锁(悬停等待)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitCom(ImplementConcurrencyBehaviorThemeLockWaitComReqDto reqDto){


      ImplementConcurrencyBehaviorThemeLockWaitRespDto distributedWaitLockingRes_1 =null;
      if((reqDto!= null&&  reqDto.getPreventConcurrentLockingUnlocking() !=null && reqDto.getPreventConcurrentLockingUnlocking().equals("LOCK"))) {
        //if(D2执行并发行为主题锁(悬停等待).防并发上锁or解锁 等于 上锁)  69452

//ModelCode: distributedWaitLocking
        ImplementConcurrencyBehaviorThemeLockWaitRespDto distributedWaitLockingRes = null;
    ImplementConcurrencyBehaviorThemeLockWaitReqDto distributedWaitLockingReq=new ImplementConcurrencyBehaviorThemeLockWaitReqDto();
  if(reqDto!=null){
      distributedWaitLockingReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1834277_1_69454
distributedWaitLockingReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1834285_1_69454
distributedWaitLockingReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1834286_1_69454
distributedWaitLockingReq.setWaitingTime(reqDto.getWaitingTime());//SimpleFieldAssign//sourceId:1834278_1_69454
distributedWaitLockingReq.setWaitTimeUnitType(reqDto.getWaitTimeUnitType());//SimpleFieldAssign//sourceId:1834279_1_69454
distributedWaitLockingReq.setDuration(reqDto.getDuration());//SimpleFieldAssign//sourceId:1834280_1_69454
distributedWaitLockingReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1834281_1_69454
    }

    /*M2执行并发行为主题锁(悬停等待)[9700]  用于新增分布式锁，支持有上锁等待并执行 */
    Assert.isNull(distributedWaitLockingReq.getRedisDataObjectCatalogue(),"D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-Redis数据对象目录不能为空",false);
Assert.isNull(distributedWaitLockingReq.getBusinessDataObject(),"D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-业务数据对象不能为空",false);
Assert.isNull(distributedWaitLockingReq.getDataObjectBatchCode(),"D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-数据对象批次标识不能为空",false);
Assert.isNull(distributedWaitLockingReq.getWaitingTime(),"D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-等待时长不能为空",false);
Assert.isNull(distributedWaitLockingReq.getWaitTimeUnitType(),"D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-等待时间单位类型不能为空",false);
      distributedWaitLockingRes = nbInterfaceMode.implementConcurrencyBehaviorThemeLockWait(distributedWaitLockingReq);


      distributedWaitLockingRes_1 = distributedWaitLockingRes;
      }
else if((reqDto!= null&&  reqDto.getPreventConcurrentLockingUnlocking() !=null && reqDto.getPreventConcurrentLockingUnlocking().equals("UNLOCK"))){
       //elseif(D2执行并发行为主题锁(悬停等待).防并发上锁or解锁 等于 解锁)  69453

//ModelCode: distributedUnlocking
        ImplementUnlockingConcBhvThemesLockComRespDto distributedUnlockingRes = null;
    ImplementUnlockingConcBhvThemesLockComReqDto distributedUnlockingReq=new ImplementUnlockingConcBhvThemesLockComReqDto();
  if(reqDto!=null){
      distributedUnlockingReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1833949_1_69455
distributedUnlockingReq.setBehaviorThemeLockCode(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1833944_1_69455
distributedUnlockingReq.setCommPrimaryKey(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1833945_1_69455
    }

    /*M2-执行解锁并发行为主题锁（特殊方法）[8393]   */
    Assert.isNull(distributedUnlockingReq.getRedisDataObjectCatalogue(),"D2执行并发行为主题锁(悬停等待)-M2-执行解锁并发行为主题锁（特殊方法）-Redis数据对象目录不能为空",false);
Assert.isNull(distributedUnlockingReq.getBehaviorThemeLockCode(),"D2执行并发行为主题锁(悬停等待)-M2-执行解锁并发行为主题锁（特殊方法）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(distributedUnlockingReq.getCommPrimaryKey(),"D2执行并发行为主题锁(悬停等待)-M2-执行解锁并发行为主题锁（特殊方法）-通用主键ID不能为空",false);
      distributedUnlockingRes = nbInterfaceMode.implementUnlockingConcBhvThemesLockCom(distributedUnlockingReq);



    }
ImplementConcurrencyBehaviorThemeLockWaitComRespDto retData = new ImplementConcurrencyBehaviorThemeLockWaitComRespDto();
  if(distributedWaitLockingRes_1!=null){
      retData.setPreventConcurrentLockingSituations(distributedWaitLockingRes_1.getPreventConcurrentLockingSituations());//SimpleFieldAssign//sourceId:1846064_1
    }




return retData;
  }
/**
   * D2新增内存业务数据(公共)[9750]
   * gen by moon at 6/6/2024, 3:48:18 PM
   */
  @Trace(operationName = "D2新增内存业务数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddMemory2BusinessDataComRespDto addMemory2BusinessDataCom(AddMemory2BusinessDataComReqDto reqDto){


      //步骤0: M2新增内存业务数据（特殊方法） - addMemory2BusinessData
     //ModelCode: addMemoryBusinessData
        AddMemory2BusinessDataRespDto addMemoryBusinessDataRes = null;
    AddMemory2BusinessDataReqDto addMemoryBusinessDataReq=new AddMemory2BusinessDataReqDto();
  if(reqDto!=null){
      addMemoryBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1852138_1
addMemoryBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1852139_1
addMemoryBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1852140_1
    }
if(reqDto!= null&&  reqDto.getMemoryBusinessDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getMemoryBusinessDataList())){
      addMemoryBusinessDataReq.setMemoryBusinessDataList(reqDto.getMemoryBusinessDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1852141_1
    }

    /*M2新增内存业务数据（特殊方法）[9749]   */
    Assert.isNull(addMemoryBusinessDataReq.getDataObjectBatchCode(),"D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-数据对象批次标识不能为空",false);
Assert.isNull(addMemoryBusinessDataReq.getBusinessDataObject(),"D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-业务数据对象不能为空",false);
Assert.isNull(addMemoryBusinessDataReq.getIsDataList(),"D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-是否是数据集对象不能为空",false);
      addMemoryBusinessDataRes = nbInterfaceMode.addMemory2BusinessData(addMemoryBusinessDataReq);




AddMemory2BusinessDataComRespDto retData = new AddMemory2BusinessDataComRespDto();





return retData;
  }
/**
   * D2执行业务组件公共字段推送内存(公共)[9753]
   * gen by moon at 6/6/2024, 3:49:00 PM
   */
  @Trace(operationName = "D2执行业务组件公共字段推送内存(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementBizModuleAccessParameterFieldComRespDto implementBizModuleAccessParameterFieldCom(ImplementBizModuleAccessParameterFieldComReqDto reqDto){


      //步骤0: M2执行业务组件公共字段推送内存（特殊方法） - implementBizModuleAccessParameterField
     //ModelCode: publicFieldCache
        ImplementBizModuleAccessParameterFieldRespDto publicFieldCacheRes = null;
    ImplementBizModuleAccessParameterFieldReqDto publicFieldCacheReq=new ImplementBizModuleAccessParameterFieldReqDto();
  if(reqDto!=null){
      publicFieldCacheReq.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:1852637_1
publicFieldCacheReq.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1852647_1
publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1852639_1
publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1852638_1
    }

    /*M2执行业务组件公共字段推送内存（特殊方法）[4834]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
    Assert.isNull(publicFieldCacheReq.getCreateInductionId(),"D2执行业务组件公共字段推送内存(公共)-M2执行业务组件公共字段推送内存（特殊方法）-创建人就职记录ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getOperationInductionId(),"D2执行业务组件公共字段推送内存(公共)-M2执行业务组件公共字段推送内存（特殊方法）-操作人就职记录ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getSpaceId(),"D2执行业务组件公共字段推送内存(公共)-M2执行业务组件公共字段推送内存（特殊方法）-创建于空间ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getAppId(),"D2执行业务组件公共字段推送内存(公共)-M2执行业务组件公共字段推送内存（特殊方法）-创建于联盟应用ID不能为空",false);
      publicFieldCacheRes = nbInterfaceMode.implementBizModuleAccessParameterField(publicFieldCacheReq);




ImplementBizModuleAccessParameterFieldComRespDto retData = new ImplementBizModuleAccessParameterFieldComRespDto();





return retData;
  }
/**
   * D2执行时间格式转换(公共)[9757]
   * gen by moon at 6/8/2024, 3:19:05 AM
   */
  @Trace(operationName = "D2执行时间格式转换(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTimeFormatConversionComRespDto implementTimeFormatConversionCom(ImplementTimeFormatConversionComReqDto reqDto){


      ImplementTimeFormatConversionRespDto timeFormatConversionRes_1 =null;
//步骤0: M2执行时间格式转换（特殊字段） - implementTimeFormatConversion
     //ModelCode: timeFormatConversion
        ImplementTimeFormatConversionRespDto timeFormatConversionRes = null;
    ImplementTimeFormatConversionReqDto timeFormatConversionReq=new ImplementTimeFormatConversionReqDto();
  if(reqDto!=null){
      timeFormatConversionReq.setComTxtField(reqDto.getComTxtField());//SimpleFieldAssign//sourceId:1855385_1
    }

    /*M2执行时间格式转换（特殊字段）[9756]  将非标时间格式转换为标准时间格式YYYY-MM-DD 00:00:00 */
    Assert.isNull(timeFormatConversionReq.getComTxtField(),"D2执行时间格式转换(公共)-M2执行时间格式转换（特殊字段）-通用文本字段不能为空",false);
      timeFormatConversionRes = nbInterfaceMode.implementTimeFormatConversion(timeFormatConversionReq);


      timeFormatConversionRes_1 = timeFormatConversionRes;

ImplementTimeFormatConversionComRespDto retData = new ImplementTimeFormatConversionComRespDto();
  if(timeFormatConversionRes_1!=null){
      retData.setComTxtField(timeFormatConversionRes_1.getComTxtField());//SimpleFieldAssign//sourceId:1855388_1
    }




return retData;
  }
/**
   * D2执行数据集取一条（含时间）(公共)[9774]
   * gen by moon at 6/9/2024, 3:59:20 PM
   */
  @Trace(operationName = "D2执行数据集取一条（含时间）(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDatasFetchLastLatestWithTimeComRespDto implementDatasFetchLastLatestWithTimeCom(ImplementDatasFetchLastLatestWithTimeComReqDto reqDto){


      ImplementDatasFetchLastLatestWithTimeRespDto dataSetFetchLastRes_1 =null;
//步骤0: M2执行数据集取最后一条（含时间）（特殊方法） - implementDatasFetchLastLatestWithTime
     //ModelCode: dataSetFetchLast
        ImplementDatasFetchLastLatestWithTimeRespDto dataSetFetchLastRes = null;
    ImplementDatasFetchLastLatestWithTimeReqDto dataSetFetchLastReq=new ImplementDatasFetchLastLatestWithTimeReqDto();
  if(reqDto!= null&&  reqDto.getComDatasList() !=null&& !CollectionUtil.isEmpty(reqDto.getComDatasList())){
      dataSetFetchLastReq.setComDatasList(reqDto.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1858588_1
    }
if(reqDto!=null){
      dataSetFetchLastReq.setOrderSizeType(reqDto.getOrderSizeType());//SimpleFieldAssign//sourceId:1860265_1
    }

    /*M2执行数据集取最一条（含时间）（特殊方法）[9773]  从数据集多条记录中取排序在数据集中最后一条记录并出参 */

      dataSetFetchLastRes = nbInterfaceMode.implementDatasFetchLastLatestWithTime(dataSetFetchLastReq);


      dataSetFetchLastRes_1 = dataSetFetchLastRes;

ImplementDatasFetchLastLatestWithTimeComRespDto retData = new ImplementDatasFetchLastLatestWithTimeComRespDto();
  if(dataSetFetchLastRes_1!=null){
      retData.setCustomField1(dataSetFetchLastRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1858600_1
retData.setCustomField2(dataSetFetchLastRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1858601_1
retData.setCustomField3(dataSetFetchLastRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1858602_1
retData.setCustomField4(dataSetFetchLastRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1858603_1
retData.setCustomField5(dataSetFetchLastRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1858604_1
retData.setCustomField6(dataSetFetchLastRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1858605_1
retData.setCustomField7(dataSetFetchLastRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1858606_1
retData.setCustomField8(dataSetFetchLastRes_1.getCustomField8());//SimpleFieldAssign//sourceId:1858607_1
retData.setComTimeField1(dataSetFetchLastRes_1.getComTimeField1());//SimpleFieldAssign//sourceId:1860266_1
retData.setComTimeField2(dataSetFetchLastRes_1.getComTimeField2());//SimpleFieldAssign//sourceId:1860267_1
    }




return retData;
  }
/**
   * D2执行单条相对地址转全路径(公共)[9811]
   * gen by moon at 6/15/2024, 4:49:14 PM
   */
  @Trace(operationName = "D2执行单条相对地址转全路径(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSingleRelativePathConvertToFullPathComRespDto implementSingleRelativePathConvertToFullPathCom(ImplementSingleRelativePathConvertToFullPathComReqDto reqDto){


      ImplementSingleRelativePathConvertToFullPathRespDto FILE_ADDRESS_ALL_PATHRes_1 =null;
//步骤0: M2执行单条相对地址转全路径（特殊方法） - implementSingleRelativePathConvertToFullPath
     //ModelCode: FILE_ADDRESS_ALL_PATH
        ImplementSingleRelativePathConvertToFullPathRespDto FILE_ADDRESS_ALL_PATHRes = null;
    ImplementSingleRelativePathConvertToFullPathReqDto FILE_ADDRESS_ALL_PATHReq=new ImplementSingleRelativePathConvertToFullPathReqDto();
  if(reqDto!=null){
      FILE_ADDRESS_ALL_PATHReq.setRelativePath(reqDto.getRelativePath());//SimpleFieldAssign//sourceId:1866983_1
    }

    /*M2执行单条相对地址转全路径（特殊方法）[9810]   */
    Assert.isNull(FILE_ADDRESS_ALL_PATHReq.getRelativePath(),"D2执行单条相对地址转全路径(公共)-M2执行单条相对地址转全路径（特殊方法）-相对地址不能为空",false);
      FILE_ADDRESS_ALL_PATHRes = nbInterfaceMode.implementSingleRelativePathConvertToFullPath(FILE_ADDRESS_ALL_PATHReq);


      FILE_ADDRESS_ALL_PATHRes_1 = FILE_ADDRESS_ALL_PATHRes;

ImplementSingleRelativePathConvertToFullPathComRespDto retData = new ImplementSingleRelativePathConvertToFullPathComRespDto();
  if(FILE_ADDRESS_ALL_PATHRes_1!=null){
      retData.setFullPath(FILE_ADDRESS_ALL_PATHRes_1.getFullPath());//SimpleFieldAssign//sourceId:1866985_1
    }




return retData;
  }
/**
   * D2查询内存业务数据列表(公共)[10423]
   * gen by moon at 12/6/2024, 10:03:21 PM
   */
  @Trace(operationName = "D2查询内存业务数据列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryMemoryBusinessDataListComRespDto queryMemoryBusinessDataListCom(QueryMemoryBusinessDataListComReqDto reqDto){


      QueryMemoryBusinessDataListRespDto queryMemoryBusinessDatasRes_1 =null;
//步骤0: M2查询内存业务数据列表（特殊方法） - queryMemoryBusinessDataList
     //ModelCode: queryMemoryBusinessDatas
        QueryMemoryBusinessDataListRespDto queryMemoryBusinessDatasRes = null;
    QueryMemoryBusinessDataListReqDto queryMemoryBusinessDatasReq=new QueryMemoryBusinessDataListReqDto();
  if(reqDto!=null){
      queryMemoryBusinessDatasReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:2033876_1
queryMemoryBusinessDatasReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:2033877_1
    }
if(reqDto!= null&&  reqDto.getMemoryBusinessResDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getMemoryBusinessResDataList())){
      queryMemoryBusinessDatasReq.setMemoryBusinessResDataList(reqDto.getMemoryBusinessResDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessResDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2033878_1
    }

    /*M2查询内存业务数据列表（特殊方法）[10422]   */
    Assert.isNull(queryMemoryBusinessDatasReq.getBusinessDataObject(),"D2查询内存业务数据列表(公共)-M2查询内存业务数据列表（特殊方法）-业务数据对象不能为空",false);
Assert.isNull(queryMemoryBusinessDatasReq.getDataObjectBatchCode(),"D2查询内存业务数据列表(公共)-M2查询内存业务数据列表（特殊方法）-数据对象批次标识不能为空",false);
      queryMemoryBusinessDatasRes = nbInterfaceMode.queryMemoryBusinessDataList(queryMemoryBusinessDatasReq);


      queryMemoryBusinessDatasRes_1 = queryMemoryBusinessDatasRes;

QueryMemoryBusinessDataListComRespDto retData = new QueryMemoryBusinessDataListComRespDto();
  if(queryMemoryBusinessDatasRes_1!=null){
      retData.setMemoryBusinessResDataList(queryMemoryBusinessDatasRes_1.getMemoryBusinessResDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessResDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2033883_1
    }




return retData;
  }
/**
   * D2查询内存业务数据列表(业务原子)[10425]
   * gen by moon at 12/6/2024, 10:03:54 PM
   */
  @Trace(operationName = "D2查询内存业务数据列表(业务原子)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListCom(QueryMemorysBusinessDataListComReqDto reqDto){


      QueryMemoryBusinessDataListComRespDto queryMemoryBusinessDataListComRespDto_1 =null;
//步骤0: D2-分析单字段批量转数据集(公共) - analysisFieldBatchDataCom
     AnalysisFieldBatchDataComRespDto analysisFieldBatchDataComRespDto = null;
    AnalysisFieldBatchDataComReqDto analysisFieldBatchDataComReqDto=new AnalysisFieldBatchDataComReqDto();
  analysisFieldBatchDataComReqDto.setCustomFieldValue1("customField1");//CUSTOM_CONVENTION//sourceId:2034010_1
analysisFieldBatchDataComReqDto.setCustomFieldValue2("customField2");//CUSTOM_CONVENTION//sourceId:2034012_1
analysisFieldBatchDataComReqDto.setCustomFieldValue3("customField3");//CUSTOM_CONVENTION//sourceId:2034014_1
analysisFieldBatchDataComReqDto.setCustomFieldValue4("customField4");//CUSTOM_CONVENTION//sourceId:2034016_1
analysisFieldBatchDataComReqDto.setCustomFieldValue5("customField5");//CUSTOM_CONVENTION//sourceId:2034018_1
analysisFieldBatchDataComReqDto.setCustomFieldValue6("customField6");//CUSTOM_CONVENTION//sourceId:2034020_1
analysisFieldBatchDataComReqDto.setCustomFieldValue7("customField7");//CUSTOM_CONVENTION//sourceId:2034022_1
analysisFieldBatchDataComReqDto.setCustomFieldValue8("customField8");//CUSTOM_CONVENTION//sourceId:2034024_1
if(reqDto!=null){
      analysisFieldBatchDataComReqDto.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:2034009_1
analysisFieldBatchDataComReqDto.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:2034011_1
analysisFieldBatchDataComReqDto.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:2034013_1
analysisFieldBatchDataComReqDto.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:2034015_1
analysisFieldBatchDataComReqDto.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:2034017_1
analysisFieldBatchDataComReqDto.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:2034019_1
analysisFieldBatchDataComReqDto.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:2034021_1
analysisFieldBatchDataComReqDto.setCustomField8(reqDto.getCustomField8());//SimpleFieldAssign//sourceId:2034023_1
    }

    /*D2-分析单字段批量转数据集(公共)[8405]   */
    Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue1(),"D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值1不能为空",false);
Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue2(),"D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值2不能为空",false);
Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue3(),"D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值3不能为空",false);
Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue4(),"D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值4不能为空",false);
Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue5(),"D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值5不能为空",false);
Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue6(),"D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值6不能为空",false);
Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue7(),"D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值7不能为空",false);
Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue8(),"D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值8不能为空",false);
      analysisFieldBatchDataComRespDto = analysisFieldBatchDataCom(analysisFieldBatchDataComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤1: D2查询内存业务数据列表(公共) - queryMemoryBusinessDataListCom
     QueryMemoryBusinessDataListComRespDto queryMemoryBusinessDataListComRespDto = null;
    if(analysisFieldBatchDataComRespDto !=null){
          QueryMemoryBusinessDataListComReqDto queryMemoryBusinessDataListComReqDto=new QueryMemoryBusinessDataListComReqDto();
  if(reqDto!=null){
      queryMemoryBusinessDataListComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:2033885_1
queryMemoryBusinessDataListComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:2033886_1
    }
if(analysisFieldBatchDataComRespDto!= null&&  analysisFieldBatchDataComRespDto.getFieldBatchDataList() !=null&& !CollectionUtil.isEmpty(analysisFieldBatchDataComRespDto.getFieldBatchDataList())){
      queryMemoryBusinessDataListComReqDto.setMemoryBusinessResDataList(analysisFieldBatchDataComRespDto.getFieldBatchDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessResDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2033884_1
    }

    /*D2查询内存业务数据列表(公共)[10423]   */
    Assert.isNull(queryMemoryBusinessDataListComReqDto.getBusinessDataObject(),"D2查询内存业务数据列表(业务原子)-D2查询内存业务数据列表(公共)-业务数据对象不能为空",false);
Assert.isNull(queryMemoryBusinessDataListComReqDto.getDataObjectBatchCode(),"D2查询内存业务数据列表(业务原子)-D2查询内存业务数据列表(公共)-数据对象批次标识不能为空",false);
      queryMemoryBusinessDataListComRespDto = queryMemoryBusinessDataListCom(queryMemoryBusinessDataListComReqDto)/*vcase invoke 同服务,同domain*/;


      queryMemoryBusinessDataListComRespDto_1 = queryMemoryBusinessDataListComRespDto;
           }

QueryMemorysBusinessDataListComRespDto retData = new QueryMemorysBusinessDataListComRespDto();
  if(queryMemoryBusinessDataListComRespDto_1!=null){
      retData.setMemoryBusinessResDataList(queryMemoryBusinessDataListComRespDto_1.getMemoryBusinessResDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessResDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2034035_1
    }




return retData;
  }
/**
   * D2执行多字段转json字符串(公共)[10436]
   * gen by moon at 12/8/2024, 3:23:01 AM
   */
  @Trace(operationName = "D2执行多字段转json字符串(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementMutFeldToJsonStringComRespDto implementMutFeldToJsonStringCom(ImplementMutFeldToJsonStringComReqDto reqDto){


      ImplementMutFeldToJsonStringRespDto mutiFieldToJsonStringRes_1 =null;
//步骤0: M2执行多字段转json字符串（特殊方法） - implementMutFeldToJsonString
     //ModelCode: mutiFieldToJsonString
        ImplementMutFeldToJsonStringRespDto mutiFieldToJsonStringRes = null;
    ImplementMutFeldToJsonStringReqDto mutiFieldToJsonStringReq=new ImplementMutFeldToJsonStringReqDto();
  if(reqDto!=null){
      mutiFieldToJsonStringReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:2034676_1
mutiFieldToJsonStringReq.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:2034681_1
mutiFieldToJsonStringReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:2034677_1
mutiFieldToJsonStringReq.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:2034679_1
mutiFieldToJsonStringReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:2034678_1
mutiFieldToJsonStringReq.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:2034680_1
mutiFieldToJsonStringReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:2034704_1
mutiFieldToJsonStringReq.setCustomFieldValue4(reqDto.getCustomFieldValue4());//SimpleFieldAssign//sourceId:2034705_1
mutiFieldToJsonStringReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:2034706_1
mutiFieldToJsonStringReq.setCustomFieldValue5(reqDto.getCustomFieldValue5());//SimpleFieldAssign//sourceId:2034707_1
mutiFieldToJsonStringReq.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:2034708_1
mutiFieldToJsonStringReq.setCustomFieldValue6(reqDto.getCustomFieldValue6());//SimpleFieldAssign//sourceId:2034709_1
mutiFieldToJsonStringReq.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:2034710_1
mutiFieldToJsonStringReq.setCustomFieldValue7(reqDto.getCustomFieldValue7());//SimpleFieldAssign//sourceId:2034711_1
mutiFieldToJsonStringReq.setCustomField8(reqDto.getCustomField8());//SimpleFieldAssign//sourceId:2034712_1
mutiFieldToJsonStringReq.setCustomFieldValue8(reqDto.getCustomFieldValue8());//SimpleFieldAssign//sourceId:2034713_1
mutiFieldToJsonStringReq.setCustomField9(reqDto.getCustomField9());//SimpleFieldAssign//sourceId:2034714_1
mutiFieldToJsonStringReq.setCustomFieldValue9(reqDto.getCustomFieldValue9());//SimpleFieldAssign//sourceId:2034715_1
mutiFieldToJsonStringReq.setCustomField10(reqDto.getCustomField10());//SimpleFieldAssign//sourceId:2034716_1
mutiFieldToJsonStringReq.setCustomFieldValue10(reqDto.getCustomFieldValue10());//SimpleFieldAssign//sourceId:2034717_1
    }

    /*M2执行多字段转json字符串（特殊方法）[10435]   */

      mutiFieldToJsonStringRes = nbInterfaceMode.implementMutFeldToJsonString(mutiFieldToJsonStringReq);


      mutiFieldToJsonStringRes_1 = mutiFieldToJsonStringRes;

ImplementMutFeldToJsonStringComRespDto retData = new ImplementMutFeldToJsonStringComRespDto();
  if(mutiFieldToJsonStringRes_1!=null){
      retData.setCustomText(mutiFieldToJsonStringRes_1.getCustomText());//SimpleFieldAssign//sourceId:2034689_1
    }




return retData;
  }
/**
   * D2新增节点(公共)[10465]
   * gen by moon at 12/18/2024, 6:45:00 PM
   */
  @Trace(operationName = "D2新增节点(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddNodeGraphDatabaseComRespDto addNodeGraphDatabaseCom(AddNodeGraphDatabaseComReqDto reqDto){


      AddNodeGraphDatabaseRespDto addNodeGraphDatabaseRes_1 =null;
//步骤0: M2新增节点（特殊方法） - addNodeGraphDatabase
     //ModelCode: addNodeGraphDatabase
        AddNodeGraphDatabaseRespDto addNodeGraphDatabaseRes = null;
    AddNodeGraphDatabaseReqDto addNodeGraphDatabaseReq=new AddNodeGraphDatabaseReqDto();
  if(reqDto!=null){
      addNodeGraphDatabaseReq.setNodeType(reqDto.getNodeType());//SimpleFieldAssign//sourceId:2037214_1
    }
if(reqDto!= null&&  reqDto.getNodeAttributeGraphDatabaseList() !=null&& !CollectionUtil.isEmpty(reqDto.getNodeAttributeGraphDatabaseList())){
      addNodeGraphDatabaseReq.setNodeAttributeGraphDatabaseList(reqDto.getNodeAttributeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeAttributeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037215_1
    }

    /*M2新增节点（特殊方法）[10455]   */
    Assert.isNull(addNodeGraphDatabaseReq.getNodeType(),"D2新增节点(公共)-M2新增节点（特殊方法）-节点类型不能为空",false);
      addNodeGraphDatabaseRes = nbInterfaceMode.addNodeGraphDatabase(addNodeGraphDatabaseReq);


      addNodeGraphDatabaseRes_1 = addNodeGraphDatabaseRes;

AddNodeGraphDatabaseComRespDto retData = new AddNodeGraphDatabaseComRespDto();
  if(addNodeGraphDatabaseRes_1!=null){
      retData.setNodeId(addNodeGraphDatabaseRes_1.getNodeId());//SimpleFieldAssign//sourceId:2037219_1
    }




return retData;
  }
/**
   * D2删除节点(公共)[10466]
   * gen by moon at 12/18/2024, 6:45:20 PM
   */
  @Trace(operationName = "D2删除节点(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteNodeGraphDatabaseComRespDto deleteNodeGraphDatabaseCom(DeleteNodeGraphDatabaseComReqDto reqDto){


      //步骤0: M2删除节点（特殊方法） - deleteNodeGraphDatabase
     //ModelCode: deleteNodeGraphDatabase
        DeleteNodeGraphDatabaseRespDto deleteNodeGraphDatabaseRes = null;
    DeleteNodeGraphDatabaseReqDto deleteNodeGraphDatabaseReq=new DeleteNodeGraphDatabaseReqDto();
  if(reqDto!=null){
      deleteNodeGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037221_1
    }

    /*M2删除节点（特殊方法）[10456]   */
    Assert.isNull(deleteNodeGraphDatabaseReq.getNodeId(),"D2删除节点(公共)-M2删除节点（特殊方法）-节点ID（唯一标识）不能为空",false);
      deleteNodeGraphDatabaseRes = nbInterfaceMode.deleteNodeGraphDatabase(deleteNodeGraphDatabaseReq);




DeleteNodeGraphDatabaseComRespDto retData = new DeleteNodeGraphDatabaseComRespDto();





return retData;
  }
/**
   * D2查询节点详情(公共)[10467]
   * gen by moon at 12/18/2024, 6:45:40 PM
   */
  @Trace(operationName = "D2查询节点详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryNodeGraphDatabaseDetailComRespDto queryNodeGraphDatabaseDetailCom(QueryNodeGraphDatabaseDetailComReqDto reqDto){


      QueryNodeGraphDatabaseDetailRespDto queryNodeDetailGraphDatabaseRes_1 =null;
//步骤0: M2查询节点详情（特殊方法） - queryNodeGraphDatabaseDetail
     //ModelCode: queryNodeDetailGraphDatabase
        QueryNodeGraphDatabaseDetailRespDto queryNodeDetailGraphDatabaseRes = null;
    QueryNodeGraphDatabaseDetailReqDto queryNodeDetailGraphDatabaseReq=new QueryNodeGraphDatabaseDetailReqDto();
  if(reqDto!=null){
      queryNodeDetailGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037228_1
queryNodeDetailGraphDatabaseReq.setNodeTagGraphDatabaseList(reqDto.getNodeTagGraphDatabaseList());//list-field-assign//sourceId:2037229_1
    }

    /*M2查询节点详情（特殊方法）[10457]   */
    Assert.isNull(queryNodeDetailGraphDatabaseReq.getNodeId(),"D2查询节点详情(公共)-M2查询节点详情（特殊方法）-节点ID（唯一标识）不能为空",false);
      queryNodeDetailGraphDatabaseRes = nbInterfaceMode.queryNodeGraphDatabaseDetail(queryNodeDetailGraphDatabaseReq);


      queryNodeDetailGraphDatabaseRes_1 = queryNodeDetailGraphDatabaseRes;

QueryNodeGraphDatabaseDetailComRespDto retData = new QueryNodeGraphDatabaseDetailComRespDto();
  if(queryNodeDetailGraphDatabaseRes_1!=null){
      retData.setNodeId(queryNodeDetailGraphDatabaseRes_1.getNodeId());//SimpleFieldAssign//sourceId:2037235_1
retData.setNodeType(queryNodeDetailGraphDatabaseRes_1.getNodeType());//SimpleFieldAssign//sourceId:2037236_1
retData.setNodeAttributeGraphDatabaseList(queryNodeDetailGraphDatabaseRes_1.getNodeAttributeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeAttributeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037237_1
    }




return retData;
  }
/**
   * D2查询节点列表(公共)[10468]
   * gen by moon at 12/18/2024, 6:46:13 PM
   */
  @Trace(operationName = "D2查询节点列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryNodeGraphDatabaseListComRespDto queryNodeGraphDatabaseListCom(QueryNodeGraphDatabaseListComReqDto reqDto){


      QueryNodeGraphDatabaseListRespDto queryNodeListGraphDatabaseRes_1 =null;
//步骤0: M2查询节点列表（特殊方法） - queryNodeGraphDatabaseList
     //ModelCode: queryNodeListGraphDatabase
        QueryNodeGraphDatabaseListRespDto queryNodeListGraphDatabaseRes = null;
    QueryNodeGraphDatabaseListReqDto queryNodeListGraphDatabaseReq=new QueryNodeGraphDatabaseListReqDto();
  if(reqDto!=null){
      queryNodeListGraphDatabaseReq.setRelationType(reqDto.getRelationType());//SimpleFieldAssign//sourceId:2037244_1
queryNodeListGraphDatabaseReq.setRelationDirection(reqDto.getRelationDirection());//SimpleFieldAssign//sourceId:2037245_1
queryNodeListGraphDatabaseReq.setNodeTagGraphDatabaseList(reqDto.getNodeTagGraphDatabaseList());//list-field-assign//sourceId:2037247_1
    }
if(reqDto!= null&&  reqDto.getNodeAttributeGraphDatabaseList() !=null&& !CollectionUtil.isEmpty(reqDto.getNodeAttributeGraphDatabaseList())){
      queryNodeListGraphDatabaseReq.setNodeAttributeGraphDatabaseList(reqDto.getNodeAttributeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeAttributeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037246_1
    }

    /*M2查询节点列表（特殊方法）[10458]   */

      queryNodeListGraphDatabaseRes = nbInterfaceMode.queryNodeGraphDatabaseList(queryNodeListGraphDatabaseReq);


      queryNodeListGraphDatabaseRes_1 = queryNodeListGraphDatabaseRes;

QueryNodeGraphDatabaseListComRespDto retData = new QueryNodeGraphDatabaseListComRespDto();
  if(queryNodeListGraphDatabaseRes_1!=null){
      retData.setNodeGraphDatabaseList(queryNodeListGraphDatabaseRes_1.getNodeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037254_1
retData.setNodeAttributeGraphDatabaseList(queryNodeListGraphDatabaseRes_1.getNodeAttributeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeAttributeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037255_1
    }

      // TODO: 2024/12/23 手写代码 
   for(NodeGraphDatabaseDto one : retData.getNodeGraphDatabaseList()){
       TreeNode elm = new TreeNode();
       elm.setChildrenList(new ArrayList<>());
       elm.setSelf(one);
       for(NodeAttributeGraphDatabaseDto subOne : retData.getNodeAttributeGraphDatabaseList()){
           if(subOne.getNodeId().equals(one.getNodeId())){
               TreeNode subNode = new TreeNode();
               subNode.setSelf(subOne);
               elm.getChildrenList().add(subNode);
           }

       }
       retData.getTreeNode().add(elm);
   }

// TODO: 2024/12/23 手写代码 
     retData.setNodeGraphDatabaseList(null);
retData.setNodeAttributeGraphDatabaseList(null);

return retData;
  }
/**
   * D2新增节点标签(公共)[10469]
   * gen by moon at 12/18/2024, 6:46:34 PM
   */
  @Trace(operationName = "D2新增节点标签(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddNodeTagGraphDatabaseComRespDto addNodeTagGraphDatabaseCom(AddNodeTagGraphDatabaseComReqDto reqDto){


      //步骤0: M2新增节点标签（特殊方法） - addNodeTagGraphDatabase
     //ModelCode: addNodeTagGraphDatabase
        AddNodeTagGraphDatabaseRespDto addNodeTagGraphDatabaseRes = null;
    AddNodeTagGraphDatabaseReqDto addNodeTagGraphDatabaseReq=new AddNodeTagGraphDatabaseReqDto();
  if(reqDto!=null){
      addNodeTagGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037258_1
addNodeTagGraphDatabaseReq.setTagName(reqDto.getTagName());//SimpleFieldAssign//sourceId:2037259_1
    }

    /*M2新增节点标签（特殊方法）[10459]   */
    Assert.isNull(addNodeTagGraphDatabaseReq.getNodeId(),"D2新增节点标签(公共)-M2新增节点标签（特殊方法）-节点ID（唯一标识）不能为空",false);
      addNodeTagGraphDatabaseRes = nbInterfaceMode.addNodeTagGraphDatabase(addNodeTagGraphDatabaseReq);




AddNodeTagGraphDatabaseComRespDto retData = new AddNodeTagGraphDatabaseComRespDto();





return retData;
  }
/**
   * D2批量增节点标签(公共)[10470]
   * gen by moon at 12/18/2024, 6:46:54 PM
   */
  @Trace(operationName = "D2批量增节点标签(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchAddNodeTagGraphDatabaseComRespDto batchAddNodeTagGraphDatabaseCom(BatchAddNodeTagGraphDatabaseComReqDto reqDto){


      //步骤0: M2批量增节点标签（特殊方法） - batchAddNodeTagGraphDatabase
     //ModelCode: batchAddNodeTagsGraphDatabase
        BatchAddNodeTagGraphDatabaseRespDto batchAddNodeTagsGraphDatabaseRes = null;
    BatchAddNodeTagGraphDatabaseReqDto batchAddNodeTagsGraphDatabaseReq=new BatchAddNodeTagGraphDatabaseReqDto();
  if(reqDto!=null){
      batchAddNodeTagsGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037264_1
batchAddNodeTagsGraphDatabaseReq.setNodeTagGraphDatabaseList(reqDto.getNodeTagGraphDatabaseList());//list-field-assign//sourceId:2037265_1
    }

    /*M2批量增节点标签（特殊方法）[10460]   */
    Assert.isNull(batchAddNodeTagsGraphDatabaseReq.getNodeId(),"D2批量增节点标签(公共)-M2批量增节点标签（特殊方法）-节点ID（唯一标识）不能为空",false);
      batchAddNodeTagsGraphDatabaseRes = nbInterfaceMode.batchAddNodeTagGraphDatabase(batchAddNodeTagsGraphDatabaseReq);




BatchAddNodeTagGraphDatabaseComRespDto retData = new BatchAddNodeTagGraphDatabaseComRespDto();





return retData;
  }
/**
   * D2删除节点标签(公共)[10471]
   * gen by moon at 12/18/2024, 6:47:14 PM
   */
  @Trace(operationName = "D2删除节点标签(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteNodeTagGraphDatabaseComRespDto deleteNodeTagGraphDatabaseCom(DeleteNodeTagGraphDatabaseComReqDto reqDto){


      //步骤0: M2删除节点标签（特殊方法） - deleteNodeTagGraphDatabase
     //ModelCode: deleteNodeGraphDatabase
        DeleteNodeTagGraphDatabaseRespDto deleteNodeGraphDatabaseRes = null;
    DeleteNodeTagGraphDatabaseReqDto deleteNodeGraphDatabaseReq=new DeleteNodeTagGraphDatabaseReqDto();
  if(reqDto!=null){
      deleteNodeGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037270_1
deleteNodeGraphDatabaseReq.setTagName(reqDto.getTagName());//SimpleFieldAssign//sourceId:2037271_1
    }

    /*M2删除节点标签（特殊方法）[10461]   */
    Assert.isNull(deleteNodeGraphDatabaseReq.getNodeId(),"D2删除节点标签(公共)-M2删除节点标签（特殊方法）-节点ID（唯一标识）不能为空",false);
      deleteNodeGraphDatabaseRes = nbInterfaceMode.deleteNodeTagGraphDatabase(deleteNodeGraphDatabaseReq);




DeleteNodeTagGraphDatabaseComRespDto retData = new DeleteNodeTagGraphDatabaseComRespDto();





return retData;
  }
/**
   * D2批量删节点标签(公共)[10472]
   * gen by moon at 12/18/2024, 6:47:34 PM
   */
  @Trace(operationName = "D2批量删节点标签(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchDeleteNodeTagGraphDatabaseComRespDto batchDeleteNodeTagGraphDatabaseCom(BatchDeleteNodeTagGraphDatabaseComReqDto reqDto){


      //步骤0: M2批量删节点标签（特殊方法） - batchDeleteNodeTagGraphDatabase
     //ModelCode: deleteNodeTagGraphDatabase
        BatchDeleteNodeTagGraphDatabaseRespDto deleteNodeTagGraphDatabaseRes = null;
    BatchDeleteNodeTagGraphDatabaseReqDto deleteNodeTagGraphDatabaseReq=new BatchDeleteNodeTagGraphDatabaseReqDto();
  if(reqDto!=null){
      deleteNodeTagGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037276_1
deleteNodeTagGraphDatabaseReq.setNodeTagGraphDatabaseList(reqDto.getNodeTagGraphDatabaseList());//list-field-assign//sourceId:2037277_1
    }

    /*M2批量删节点标签（特殊方法）[10462]   */
    Assert.isNull(deleteNodeTagGraphDatabaseReq.getNodeId(),"D2批量删节点标签(公共)-M2批量删节点标签（特殊方法）-节点ID（唯一标识）不能为空",false);
      deleteNodeTagGraphDatabaseRes = nbInterfaceMode.batchDeleteNodeTagGraphDatabase(deleteNodeTagGraphDatabaseReq);




BatchDeleteNodeTagGraphDatabaseComRespDto retData = new BatchDeleteNodeTagGraphDatabaseComRespDto();





return retData;
  }
/**
   * D2新增节点关系(公共)[10473]
   * gen by moon at 5/8/2025, 8:43:35 PM
   */
  @Trace(operationName = "D2新增节点关系(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddNodeRelationGraphDatabaseComRespDto addNodeRelationGraphDatabaseCom(AddNodeRelationGraphDatabaseComReqDto reqDto){


      //步骤0: M2新增节点关系（特殊方法） - addNodeRelationGraphDatabase
     //ModelCode: addNodeRelationGraphDatabase
        AddNodeRelationGraphDatabaseRespDto addNodeRelationGraphDatabaseRes = null;
    AddNodeRelationGraphDatabaseReqDto addNodeRelationGraphDatabaseReq=new AddNodeRelationGraphDatabaseReqDto();
  if(reqDto!=null){
      addNodeRelationGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037291_1
addNodeRelationGraphDatabaseReq.setRelationNodeId(reqDto.getRelationNodeId());//SimpleFieldAssign//sourceId:2037292_1
addNodeRelationGraphDatabaseReq.setRelationType(reqDto.getRelationType());//SimpleFieldAssign//sourceId:2037296_1
addNodeRelationGraphDatabaseReq.setRelationDirection(reqDto.getRelationDirection());//SimpleFieldAssign//sourceId:2037297_1
    }
if(reqDto!= null&&  reqDto.getNodeRelationAttrGraphDatabaseList() !=null&& !CollectionUtil.isEmpty(reqDto.getNodeRelationAttrGraphDatabaseList())){
addNodeRelationGraphDatabaseReq.setNodeRelationAttrGraphDatabaseList(reqDto.getNodeRelationAttrGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeRelationAttrGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037298_1
    }

    /*M2新增节点关系（特殊方法）[10463]   */
    Assert.isNull(addNodeRelationGraphDatabaseReq.getNodeId(),"D2新增节点关系(公共)-M2新增节点关系（特殊方法）-节点ID（唯一标识）不能为空",false);
Assert.isNull(addNodeRelationGraphDatabaseReq.getRelationNodeId(),"D2新增节点关系(公共)-M2新增节点关系（特殊方法）-关联节点ID（唯一标识）不能为空",false);
      addNodeRelationGraphDatabaseRes = nbInterfaceMode.addNodeRelationGraphDatabase(addNodeRelationGraphDatabaseReq);




AddNodeRelationGraphDatabaseComRespDto retData = new AddNodeRelationGraphDatabaseComRespDto();





return retData;
  }
/**
   * D2删除节点关系(公共)[10474]
   * gen by moon at 12/18/2024, 6:48:21 PM
   */
  @Trace(operationName = "D2删除节点关系(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteNodeRelationGraphDatabaseComRespDto deleteNodeRelationGraphDatabaseCom(DeleteNodeRelationGraphDatabaseComReqDto reqDto){


      //步骤0: M2删除节点关系（特殊方法） - deleteNodeRelationGraphDatabase
     //ModelCode: deleteNodeRelationGraphDatabase
        DeleteNodeRelationGraphDatabaseRespDto deleteNodeRelationGraphDatabaseRes = null;
    DeleteNodeRelationGraphDatabaseReqDto deleteNodeRelationGraphDatabaseReq=new DeleteNodeRelationGraphDatabaseReqDto();
  if(reqDto!=null){
      deleteNodeRelationGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037285_1
deleteNodeRelationGraphDatabaseReq.setRelationType(reqDto.getRelationType());//SimpleFieldAssign//sourceId:2037286_1
deleteNodeRelationGraphDatabaseReq.setRelationDirection(reqDto.getRelationDirection());//SimpleFieldAssign//sourceId:2037287_1
    }

    /*M2删除节点关系（特殊方法）[10464]   */
    Assert.isNull(deleteNodeRelationGraphDatabaseReq.getNodeId(),"D2删除节点关系(公共)-M2删除节点关系（特殊方法）-节点ID（唯一标识）不能为空",false);
      deleteNodeRelationGraphDatabaseRes = nbInterfaceMode.deleteNodeRelationGraphDatabase(deleteNodeRelationGraphDatabaseReq);




DeleteNodeRelationGraphDatabaseComRespDto retData = new DeleteNodeRelationGraphDatabaseComRespDto();





return retData;
  }
/**
   * D2执行数据导出excel(公共)[10476]
   * gen by moon at 12/30/2024, 6:11:44 PM
   */
  @Trace(operationName = "D2执行数据导出excel(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementExportDatatoExcelComRespDto implementExportDatatoExcelCom(ImplementExportDatatoExcelComReqDto reqDto){


      //步骤0: M2执行数据导出excel（特殊方法） - implementExportDataToExcel
     //ModelCode: exportDataToExcel
        ImplementExportDataToExcelRespDto exportDataToExcelRes = null;
    ImplementExportDataToExcelReqDto exportDataToExcelReq=new ImplementExportDataToExcelReqDto();
  if(reqDto!=null){
      exportDataToExcelReq.setExportExcelFileName(reqDto.getExportExcelFileName());//SimpleFieldAssign//sourceId:2037366_1
exportDataToExcelReq.setExportFileFormat(reqDto.getExportFileFormat());//SimpleFieldAssign//sourceId:2037369_1
    }
if(reqDto!= null&&  reqDto.getExcelHeaderFieldDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getExcelHeaderFieldDataList())){
      exportDataToExcelReq.setExcelHeaderFieldDataList(reqDto.getExcelHeaderFieldDataList().stream().map(item -> BeanUtil.toBean(item, ExcelHeaderFieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037361_1
    }
if(reqDto!= null&&  reqDto.getExportDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getExportDataList())){
      exportDataToExcelReq.setExportDataList(reqDto.getExportDataList().stream().map(item -> BeanUtil.toBean(item, ExportDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037362_1
    }

    /*M2执行数据导出excel（特殊方法）[10475]   */

      exportDataToExcelRes = nbInterfaceMode.implementExportDataToExcel(exportDataToExcelReq);




ImplementExportDatatoExcelComRespDto retData = new ImplementExportDatatoExcelComRespDto();





return retData;
  }
/**
   * D2新增MQ队列数据(公共)[10483]
   * gen by moon at 3/22/2025, 5:13:23 PM
   */
  @Trace(operationName = "D2新增MQ队列数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddMessageQueueDataComRespDto addMessageQueueDataCom(AddMessageQueueDataComReqDto reqDto){


      //步骤0: M2-新增MQ队列数据（特殊方法） - addMessageQueueData
     //ModelCode: addMqQueueData
        AddMessageQueueDataRespDto addMqQueueDataRes = null;
    AddMessageQueueDataReqDto addMqQueueDataReq=new AddMessageQueueDataReqDto();
  addMqQueueDataReq.setMqSubNumer(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:2043179_1
  if(reqDto!=null){
      addMqQueueDataReq.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039424_1
addMqQueueDataReq.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039425_1
    }
if(reqDto!= null&&  reqDto.getFieldDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getFieldDataList())){
      addMqQueueDataReq.setFieldDataList(reqDto.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2039426_1
    }

    /*M2-新增MQ队列数据（特殊方法）[10482] MQ队列分区号目前约定为0，涉及新增、修改、查询，方便以后扩展使用  */
    Assert.isNull(addMqQueueDataReq.getMqQueueName(),"D2新增MQ队列数据(公共)-M2-新增MQ队列数据（特殊方法）-MQ队列名称不能为空",false);
Assert.isNull(addMqQueueDataReq.getMqPrimaryId(),"D2新增MQ队列数据(公共)-M2-新增MQ队列数据（特殊方法）-MQ队列唯一主键ID不能为空",false);
Assert.isNull(addMqQueueDataReq.getMqSubNumer(),"D2新增MQ队列数据(公共)-M2-新增MQ队列数据（特殊方法）-MQ子队列序号值不能为空",false);
      addMqQueueDataRes = nbInterfaceMode.addMessageQueueData(addMqQueueDataReq);




AddMessageQueueDataComRespDto retData = new AddMessageQueueDataComRespDto();





return retData;
  }
/**
   * D2执行注册MQ队列(公共)[10485]
   * gen by moon at 3/4/2025, 11:08:36 AM
   */
  @Trace(operationName = "D2执行注册MQ队列(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddMessageQueueComRespDto addMessageQueueCom(AddMessageQueueComReqDto reqDto){


      //步骤0: M2-执行注册MQ队列（特殊方法） - registerMessageQueue
     //ModelCode: registerMqQueue
        RegisterMessageQueueRespDto registerMqQueueRes = null;
    RegisterMessageQueueReqDto registerMqQueueReq=new RegisterMessageQueueReqDto();
  if(reqDto!=null){
      registerMqQueueReq.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039434_1
registerMqQueueReq.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039435_1
    }

    /*M2-执行注册MQ队列（特殊方法）[10484]   */
    Assert.isNull(registerMqQueueReq.getMqQueueName(),"D2执行注册MQ队列(公共)-M2-执行注册MQ队列（特殊方法）-MQ队列名称不能为空",false);
Assert.isNull(registerMqQueueReq.getMqPrimaryId(),"D2执行注册MQ队列(公共)-M2-执行注册MQ队列（特殊方法）-MQ队列唯一主键ID不能为空",false);
      registerMqQueueRes = nbInterfaceMode.registerMessageQueue(registerMqQueueReq);




AddMessageQueueComRespDto retData = new AddMessageQueueComRespDto();





return retData;
  }
/**
   * D2修改MQ队列最小值(公共)[10487]
   * gen by moon at 3/22/2025, 5:13:26 PM
   */
  @Trace(operationName = "D2修改MQ队列最小值(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UpdateMessageQueueComRespDto updateMessageQueueCom(UpdateMessageQueueComReqDto reqDto){


      //步骤0: M2-修改MQ队列最小值（特殊方法） - updateMessageQueue
     //ModelCode: updateCurMqQueueMin
        UpdateMessageQueueRespDto updateCurMqQueueMinRes = null;
    UpdateMessageQueueReqDto updateCurMqQueueMinReq=new UpdateMessageQueueReqDto();
  updateCurMqQueueMinReq.setMqSubNumer(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:2043181_1
  if(reqDto!=null){
      updateCurMqQueueMinReq.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039454_1
updateCurMqQueueMinReq.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039455_1
updateCurMqQueueMinReq.setMqQueueMinimum(reqDto.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2039456_1
    }

    /*M2-修改MQ队列最小值（特殊方法）[10486]   */
    Assert.isNull(updateCurMqQueueMinReq.getMqQueueName(),"D2修改MQ队列最小值(公共)-M2-修改MQ队列最小值（特殊方法）-MQ队列名称不能为空",false);
Assert.isNull(updateCurMqQueueMinReq.getMqPrimaryId(),"D2修改MQ队列最小值(公共)-M2-修改MQ队列最小值（特殊方法）-MQ队列唯一主键ID不能为空",false);
Assert.isNull(updateCurMqQueueMinReq.getMqQueueMinimum(),"D2修改MQ队列最小值(公共)-M2-修改MQ队列最小值（特殊方法）-MQ队列最小值不能为空",false);
Assert.isNull(updateCurMqQueueMinReq.getMqSubNumer(),"D2修改MQ队列最小值(公共)-M2-修改MQ队列最小值（特殊方法）-MQ子队列序号值不能为空",false);
      updateCurMqQueueMinRes = nbInterfaceMode.updateMessageQueue(updateCurMqQueueMinReq);




UpdateMessageQueueComRespDto retData = new UpdateMessageQueueComRespDto();





return retData;
  }
/**
   * D2查询MQ队列数据列表(公共)[10489]
   * gen by moon at 3/22/2025, 5:13:29 PM
   */
  @Trace(operationName = "D2查询MQ队列数据列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryMessageQueueListComRespDto queryMessageQueueListCom(QueryMessageQueueListComReqDto reqDto){


      QueryMessageQueueDataListRespDto queryMqQueueDataListRes_1 =null;
//步骤0: M2-查询MQ队列数据列表（特殊方法） - queryMessageQueueDataList
     //ModelCode: queryMqQueueDataList
        QueryMessageQueueDataListRespDto queryMqQueueDataListRes = null;
    QueryMessageQueueDataListReqDto queryMqQueueDataListReq=new QueryMessageQueueDataListReqDto();
  queryMqQueueDataListReq.setMqSubNumer(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:2043183_1
  if(reqDto!=null){
      queryMqQueueDataListReq.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2040149_1
queryMqQueueDataListReq.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040150_1
    }
if(reqDto!= null&&  reqDto.getMessageQueueDataList() !=null&& !CollectionUtil.isEmpty(reqDto.getMessageQueueDataList())){
      queryMqQueueDataListReq.setMessageQueueDataList(reqDto.getMessageQueueDataList().stream().map(item -> BeanUtil.toBean(item, MessageQueueDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2039877_1
    }

    /*M2-查询MQ队列数据列表（特殊方法）[10488]   */

      queryMqQueueDataListRes = nbInterfaceMode.queryMessageQueueDataList(queryMqQueueDataListReq);


      queryMqQueueDataListRes_1 = queryMqQueueDataListRes;

QueryMessageQueueListComRespDto retData = new QueryMessageQueueListComRespDto();
  if(queryMqQueueDataListRes_1!=null){
      retData.setMqQueueName(queryMqQueueDataListRes_1.getMqQueueName());//SimpleFieldAssign//sourceId:2039466_1
retData.setMqPrimaryId(queryMqQueueDataListRes_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039467_1
retData.setMqQueueMinimum(queryMqQueueDataListRes_1.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2039468_1
retData.setFieldDataList(queryMqQueueDataListRes_1.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2039469_1
    }




return retData;
  }
/**
   * D2遍历查询有数据的MQ队列(公共)[10498]
   * gen by moon at 3/22/2025, 5:13:32 PM
   */
  @Trace(operationName = "D2遍历查询有数据的MQ队列(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryHaveDataMqQueueDetailComRespDto queryHaveDataMqQueueDetailCom(QueryHaveDataMqQueueDetailComReqDto reqDto){


      QueryHaveDataMqQueueDetailRespDto queryHaveDataMqQueueRes_1 =null;
//步骤0: M2-遍历查询有数据的MQ队列 - queryHaveDataMqQueueDetail
     //ModelCode: queryHaveDataMqQueue
        QueryHaveDataMqQueueDetailRespDto queryHaveDataMqQueueRes = null;
    QueryHaveDataMqQueueDetailReqDto queryHaveDataMqQueueReq=new QueryHaveDataMqQueueDetailReqDto();
  queryHaveDataMqQueueReq.setMqSubNumer(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:2043185_1

    /*M2-遍历查询有数据的MQ队列[10497]   */
    Assert.isNull(queryHaveDataMqQueueReq.getMqSubNumer(),"D2遍历查询有数据的MQ队列(公共)-M2-遍历查询有数据的MQ队列-MQ子队列序号值不能为空",false);
      queryHaveDataMqQueueRes = nbInterfaceMode.queryHaveDataMqQueueDetail(queryHaveDataMqQueueReq);


      queryHaveDataMqQueueRes_1 = queryHaveDataMqQueueRes;

QueryHaveDataMqQueueDetailComRespDto retData = new QueryHaveDataMqQueueDetailComRespDto();
  if(queryHaveDataMqQueueRes_1!=null){
      retData.setMqQueueName(queryHaveDataMqQueueRes_1.getMqQueueName());//SimpleFieldAssign//sourceId:2040145_1
retData.setMqPrimaryId(queryHaveDataMqQueueRes_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040146_1
    }




return retData;
  }
/**
   * D2执行名称副本处理(公共)[10540]
   * gen by moon at 6/2/2025, 12:03:41 PM
   */
  @Trace(operationName = "D2执行名称副本处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementNameCopyHandleComRespDto implementNameCopyHandleCom(ImplementNameCopyHandleComReqDto reqDto){


      ImplementNameCopyHandleRespDto nameCopyRes_1 =null;
//步骤0: M2执行名称副本处理（特殊方法） - implementNameCopyHandle
     //ModelCode: nameCopy
        ImplementNameCopyHandleRespDto nameCopyRes = null;
    ImplementNameCopyHandleReqDto nameCopyReq=new ImplementNameCopyHandleReqDto();
  if(reqDto!=null){
      nameCopyReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:2047928_1
nameCopyReq.setCopyName(reqDto.getCopyName());//SimpleFieldAssign//sourceId:2047929_1
    }
if(reqDto!= null&&  reqDto.getComDatasList() !=null&& !CollectionUtil.isEmpty(reqDto.getComDatasList())){
      nameCopyReq.setComDatasList(reqDto.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2047927_1
    }

    /*M2执行名称副本处理（特殊方法）[10539]   */
    Assert.isNull(nameCopyReq.getCustomField(),"D2执行名称副本处理(公共)-M2执行名称副本处理（特殊方法）-自定义字段不能为空",false);
      nameCopyRes = nbInterfaceMode.implementNameCopyHandle(nameCopyReq);


      nameCopyRes_1 = nameCopyRes;

ImplementNameCopyHandleComRespDto retData = new ImplementNameCopyHandleComRespDto();
  if(nameCopyRes_1!=null){
      retData.setNameCopyValue(nameCopyRes_1.getNameCopyValue());//SimpleFieldAssign//sourceId:2047934_1
    }




return retData;
  }



    //
}
